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

package/lib/toolbar/toolbar.component.d.ts

@@ -0,0 +1,167 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { MenuItem } from 'primeng/api';
+import { IImageInfo } from '../contracts/image.contract';
+import { PlotType, PlotTypeDescriptor } from '../contracts/plot-type';
+import { ToolbarToolVisibility } from '../contracts/toolbar-config';
+import * as i0 from "@angular/core";
+/**
+ * Presentational toolbar for the plotting viewport.
+ *
+ * Renders the plot-type selector, colormap/LUT controls, stack navigation,
+ * image actions (download / autoscale / pipeline), viewport zoom/pan, the
+ * Surface-3D camera controls, and the region-drawing tools — plus the plotting
+ * help dialog. It owns no rendering or visualization state: the host
+ * (VisualizerComponent) stays the orchestrator, passing state in via `@Input` and
+ * handling every action via `@Output`. The same actions are also driven by the
+ * diagram's right-click context menu and keyboard shortcuts, so keeping the
+ * handlers in the host avoids duplicating that logic.
+ */
+export declare class ToolbarComponent implements OnChanges {
+    /** Current image (gates which control groups are shown). */
+    imageInfo: IImageInfo | undefined;
+    /** Plot types the active backend advertises. */
+    plotTypeOptions: PlotTypeDescriptor[];
+    selectedPlotType: PlotType;
+    /** Isosurface band as a 0–255 slider position (mapped onto the volume's real
+     *  intensity range by the renderer). Defaults to the full range. */
+    isoRange: number[];
+    maxIndex: number;
+    zIndex: number;
+    /** True for any 2D (non Surface-3D) plot type. */
+    isHeatmap: boolean;
+    activeDragMode: string | null;
+    activeSurface3dMode: string;
+    /** Whether the napari 3D axes/scale gizmo is currently shown (drives the toggle's look). */
+    axesVisible: boolean;
+    wireframeActive: boolean;
+    /** Active napari 3D decimate factor (1 = Full … 8 = ⅛; default ½). */
+    resolutionScale: number;
+    /** Decimate-factor options for the Resolution dropdown. */
+    readonly decimateOptions: {
+        label: string;
+        value: number;
+    }[];
+    wandSensitivity: number;
+    brushSize: number;
+    vertexEraserRadius: number;
+    /** Whether a region action is available to undo (jit-ui#85). Greys out the
+     *  Undo button when false (nothing done yet, or all steps already undone). */
+    canUndo: boolean;
+    /** Whether an undone region action is available to redo (jit-ui#85). Greys
+     *  out the Redo button when false. */
+    canRedo: boolean;
+    stackOptions: {
+        name: string;
+        val: string;
+    }[];
+    /** Which toolbar groups to show. Defaults to the full toolbar; the host forwards
+     *  the consumer's choice (e.g. the pipeline shows only zoom + region tools). */
+    tools: Required<ToolbarToolVisibility>;
+    /** Current image-smoothing state (drives the Smoothen toggle button look).
+     *  `false` = nearest-neighbour (crisp raw pixels), the default. */
+    imageSmoothingEnabled: boolean;
+    /** SAM model picker options + current selection (jit-ui#90 P1). */
+    samModels: {
+        id: string;
+        label: string;
+    }[];
+    samModelId: string;
+    selectPlotType: EventEmitter<PlotType>;
+    /** Intensity (LINE) mode: add another colored line ROI + inset trace. */
+    addProfileLine: EventEmitter<void>;
+    /** Toggle image smoothing (bilinear) vs nearest-neighbour (crisp pixels). */
+    toggleImageSmoothing: EventEmitter<void>;
+    isoRangeChange: EventEmitter<number[] | undefined>;
+    /** Open the Channels & Histogram dialog (brightness/contrast, colormap, …). */
+    openChannelHistogram: EventEmitter<void>;
+    openRegionEditor: EventEmitter<void>;
+    selectStackOption: EventEmitter<{
+        name: string;
+        val: string;
+    }>;
+    zScrub: EventEmitter<number | undefined>;
+    zSlide: EventEmitter<number | undefined>;
+    zIndexInput: EventEmitter<number>;
+    reloadAndPlot: EventEmitter<void>;
+    downloadImage: EventEmitter<void>;
+    autoscaleImage: EventEmitter<void>;
+    toggleDragMode: EventEmitter<string>;
+    zoomIn: EventEmitter<void>;
+    zoomOut: EventEmitter<void>;
+    toggleSurface3dMode: EventEmitter<string>;
+    resetSurfaceCamera: EventEmitter<void>;
+    /** Toggle the napari 3D coordinate-axes / scale gizmo on/off. */
+    toggleAxes: EventEmitter<void>;
+    /** Toggle the napari surface wireframe (edges) on/off. */
+    toggleWireframe: EventEmitter<void>;
+    /** Change the napari 3D decimate factor (reloads at the new resolution). */
+    selectResolution: EventEmitter<number>;
+    deleteRegion: EventEmitter<void>;
+    /** Undo the last region action (jit-ui#85). */
+    undoRegion: EventEmitter<void>;
+    /** Redo the last undone region action (jit-ui#85). */
+    redoRegion: EventEmitter<void>;
+    /** Run box-prompted SAM segmentation on the drawn rectangles (jit-ui#90). */
+    segmentRegions: EventEmitter<void>;
+    /** Run cellpose-SAM (auto) inside each drawn rectangle's crop (jit-ui#90). */
+    segmentCellpose: EventEmitter<void>;
+    /** SAM model picker (jit-ui#90 P1). */
+    samModelChange: EventEmitter<string>;
+    wandSensitivityChange: EventEmitter<number | undefined>;
+    brushSizeChange: EventEmitter<number | undefined>;
+    vertexEraserRadiusChange: EventEmitter<number | undefined>;
+    /** Sliders' bounds — toolbar UI constants (the values are host-owned). */
+    readonly wandSensitivityMin = 0.5;
+    readonly wandSensitivityMax = 10;
+    readonly wandSensitivityStep = 0.1;
+    readonly brushSizeMin = 5;
+    readonly brushSizeMax = 300;
+    readonly brushSizeStep = 5;
+    readonly vertexEraserRadiusMin = 5;
+    readonly vertexEraserRadiusMax = 300;
+    readonly vertexEraserRadiusStep = 5;
+    readonly isoValueMin = 0;
+    readonly isoValueMax = 255;
+    readonly isoValueStep = 1;
+    displayHelpDialog: boolean;
+    /** Model picker for the Segment button's dropdown menu. The active model
+     *  (`samModelId`) is marked with a check; selecting an item emits
+     *  `samModelChange` (jit-ui#90 P1).
+     *
+     *  Held as a stable array (rebuilt only when `samModels`/`samModelId` change),
+     *  NOT a getter: a getter returns a fresh array with new `command` closures on
+     *  every change-detection tick, which makes the bound `p-menu` overlay rebuild
+     *  its DOM mid-interaction and swallow the click on a menu item. */
+    samMenuItems: MenuItem[];
+    /** Rebuild the SAM model menu when the model list or active selection
+     *  changes (keeps the array reference stable across other CD ticks). */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** The Image plot type renders as a natively pan/zoom-able raster, so the
+     *  generic zoom/pan tools are hidden. */
+    get isImageView(): boolean;
+    /** A plot-type icon is a PrimeNG font glyph (e.g. `pi pi-image`) rather than an
+     *  SVG asset path — drives which element the selector item template renders. */
+    isPiIcon(icon: string | undefined): boolean;
+    /** Backends with a vertex-editing region overlay: OSD Image and napari-js WebGPU image
+     *  (jit-ui#102). Gates the polygon / add-vertex / delete-vertex / Bézier-convert tools. */
+    get supportsRegionVertexTools(): boolean;
+    /** Plot types that scrub a z-stack live (the renderer swaps the slice in place): the OSD Image
+     *  view, the napari-js WebGPU image, and the napari-js surface — which rebuilds the height field
+     *  from the picked slice (jit-ui#102). Drives the per-slice slider. */
+    get showsLiveSliceScrubber(): boolean;
+    /** Any napari-js WebGPU plot type. The single-image/stack toggle + slice-number field are
+     *  Plotly-only stack controls, so they're hidden for napari (jit-ui#102). */
+    get isNapariMode(): boolean;
+    /** ISOSURFACE (Plotly or napari-js WebGPU, either resolution) shows the isovalue range slider. */
+    get isIsosurfaceMode(): boolean;
+    /** The napari-js WebGPU surface — shows the wireframe toggle. */
+    get isNapariSurfaceMode(): boolean;
+    /** Any napari-js WebGPU 3D type (volume/isosurface/surface) — shows the Resolution control. */
+    get isNapari3dMode(): boolean;
+    /** Intensity profile lines are Region-based and available in the Heatmap and
+     *  Image plot types, which show the Intensity tool group. */
+    get isIntensityCapable(): boolean;
+    showHelp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "plotting-toolbar", never, { "imageInfo": { "alias": "imageInfo"; "required": false; }; "plotTypeOptions": { "alias": "plotTypeOptions"; "required": false; }; "selectedPlotType": { "alias": "selectedPlotType"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "activeSurface3dMode": { "alias": "activeSurface3dMode"; "required": false; }; "axesVisible": { "alias": "axesVisible"; "required": false; }; "wireframeActive": { "alias": "wireframeActive"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; "wandSensitivity": { "alias": "wandSensitivity"; "required": false; }; "brushSize": { "alias": "brushSize"; "required": false; }; "vertexEraserRadius": { "alias": "vertexEraserRadius"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; "stackOptions": { "alias": "stackOptions"; "required": false; }; "tools": { "alias": "tools"; "required": false; }; "imageSmoothingEnabled": { "alias": "imageSmoothingEnabled"; "required": false; }; "samModels": { "alias": "samModels"; "required": false; }; "samModelId": { "alias": "samModelId"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "addProfileLine": "addProfileLine"; "toggleImageSmoothing": "toggleImageSmoothing"; "isoRangeChange": "isoRangeChange"; "openChannelHistogram": "openChannelHistogram"; "openRegionEditor": "openRegionEditor"; "selectStackOption": "selectStackOption"; "zScrub": "zScrub"; "zSlide": "zSlide"; "zIndexInput": "zIndexInput"; "reloadAndPlot": "reloadAndPlot"; "downloadImage": "downloadImage"; "autoscaleImage": "autoscaleImage"; "toggleDragMode": "toggleDragMode"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "toggleSurface3dMode": "toggleSurface3dMode"; "resetSurfaceCamera": "resetSurfaceCamera"; "toggleAxes": "toggleAxes"; "toggleWireframe": "toggleWireframe"; "selectResolution": "selectResolution"; "deleteRegion": "deleteRegion"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "segmentRegions": "segmentRegions"; "segmentCellpose": "segmentCellpose"; "samModelChange": "samModelChange"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,64 @@
+import { WandService } from '../wand/wand.service';
+import { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';
+import * as i0 from "@angular/core";
+/**
+ * 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).
+ */
+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;
+}
+/**
+ * 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.
+ *
+ * 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;
+    private host;
+    private 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;
+    /** Set eraser radius in matrix-pixel (image pixel) coordinates. */
+    setRadius(radius: number): void;
+    private createOverlay;
+    private destroyOverlay;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private updateCursor;
+    /** Draw the eraser radius circle at the current cursor position. */
+    private drawCursor;
+    /**
+     * 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.
+     */
+    private applyAtClient;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VertexEraserToolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VertexEraserToolService>;
+}

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

@@ -0,0 +1,149 @@
+import { WandOptions, WandService } from './wand.service';
+import { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';
+import * as i0 from "@angular/core";
+/**
+ * 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.
+ *
+ * Keeping it explicit makes the dependency one-way: WandToolService never
+ * imports PlotlyService directly. PlotlyService satisfies this interface
+ * structurally and binds itself via `bindHost(this)`.
+ */
+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;
+    private host;
+    private overlay;
+    private active;
+    /**
+     * 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.
+     */
+    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 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;
+    /** 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;
+    private createOverlay;
+    private destroyOverlay;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private resetStroke;
+    /**
+     * 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.
+     */
+    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;
+    /**
+     * 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.
+     */
+    private commitStroke;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WandToolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WandToolService>;
+}

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

@@ -0,0 +1,133 @@
+import { Polygon } from '../../models/region';
+import { IWandOptions, WandType } from '../../contracts/display-types';
+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;
+}
+/**
+ * Wand region-growing tool, modelled after QuPath's WandToolEventHandler.
+ *
+ * Given an image and a click position, extracts a square patch around the
+ * click, optionally blurs it, computes a local threshold, runs a fixed-range
+ * flood fill from the centre, closes the resulting mask, and returns the
+ * traced contour as a polygon in image coordinates.
+ */
+export 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.
+     */
+    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.
+     */
+    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).
+     */
+    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}.
+     */
+    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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WandService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WandService>;
+}

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

@@ -0,0 +1,49 @@
+import * as i0 from "@angular/core";
+/**
+ * Collaboration interface the zoom-to-box tool needs from PlotlyService.
+ */
+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;
+}
+/**
+ * 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 {
+    private host;
+    private 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;
+    private drawSelection;
+    private clearCanvas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomToBoxToolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomToBoxToolService>;
+}

package/lib/visualization.module.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./visualizer.component";
+import * as i2 from "./toolbar/toolbar.component";
+import * as i3 from "./region-editor/region-editor.component";
+import * as i4 from "./hex-color-picker/hex-color-picker.component";
+import * as i5 from "./channel-histogram/channel-histogram.component";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/forms";
+import * as i8 from "primeng/toolbar";
+import * as i9 from "primeng/button";
+import * as i10 from "primeng/menu";
+import * as i11 from "primeng/dropdown";
+import * as i12 from "primeng/slider";
+import * as i13 from "primeng/treeselect";
+import * as i14 from "primeng/inputnumber";
+import * as i15 from "primeng/dialog";
+import * as i16 from "primeng/contextmenu";
+import * as i17 from "primeng/progressbar";
+import * as i18 from "primeng/toast";
+import * as i19 from "primeng/tooltip";
+import * as i20 from "primeng/ripple";
+import * as i21 from "primeng/table";
+import * as i22 from "primeng/paginator";
+import * as i23 from "primeng/overlaypanel";
+import * as i24 from "primeng/confirmdialog";
+import * as i25 from "primeng/inputtext";
+import * as i26 from "primeng/checkbox";
+import * as i27 from "primeng/radiobutton";
+import * as i28 from "primeng/selectbutton";
+/**
+ * Self-contained plotting UI: the {@link VisualizerComponent} (plot surface
+ * + render orchestration), its {@link ToolbarComponent}, and the
+ * {@link RegionEditorComponent} (the Regions tab table/editor). Consumers embed
+ * `<visualizer>` / `<region-editor>` and need know nothing about the toolbar,
+ * the rendering backends, or region file I/O (supplied via the REGION_IO_PORT).
+ *
+ * Also exports {@link HexColorPickerComponent} (`<hex-color-picker>`) as a
+ * standalone reusable picker (`[color]` in, `(colorChange)` out) so consuming
+ * apps can use it on its own, the same way as the visualizer and region editor.
+ */
+export declare class VisualizationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<VisualizationModule, [typeof i1.VisualizerComponent, typeof i2.ToolbarComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent], [typeof i6.CommonModule, typeof i7.FormsModule, typeof i8.ToolbarModule, typeof i9.ButtonModule, typeof i10.MenuModule, typeof i11.DropdownModule, typeof i12.SliderModule, typeof i13.TreeSelectModule, typeof i14.InputNumberModule, typeof i15.DialogModule, typeof i16.ContextMenuModule, typeof i17.ProgressBarModule, typeof i18.ToastModule, typeof i19.TooltipModule, typeof i20.RippleModule, typeof i21.TableModule, typeof i22.PaginatorModule, typeof i23.OverlayPanelModule, typeof i24.ConfirmDialogModule, typeof i25.InputTextModule, typeof i26.CheckboxModule, typeof i27.RadioButtonModule, typeof i28.SelectButtonModule], [typeof i1.VisualizerComponent, typeof i3.RegionEditorComponent, typeof i4.HexColorPickerComponent, typeof i5.ChannelHistogramComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<VisualizationModule>;
+}