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

package/lib/toolbar/tool-kit/frame-pixels.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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).
+ */
+/** A row-major RGBA readback (alpha is ignored). */
+export interface PackedFrame {
+    readonly data: Uint8ClampedArray;
+    readonly width: number;
+    readonly height: number;
+    readonly channels: 4;
+}
+/** `[y][x]` grayscale values, or `[y][x]` `[r, g, b]` tuples. */
+export type NestedFrame = number[][] | number[][][];
+/** One frame of `CachedImageData.frames`. */
+export type CachedFrame = NestedFrame | PackedFrame;
+/** Whether `frame` is the packed RGBA form. */
+export declare function isPackedFrame(frame: unknown): frame is PackedFrame;
+/** Wrap a row-major RGBA readback as a frame, without copying it. */
+export declare function packedFrame(data: Uint8ClampedArray, width: number, height: number): PackedFrame;
+/** Reads one frame's pixels whatever its form. */
+export interface FramePixels {
+    /**
+     * Pixel (x, y) as RGB in `out[0..2]` (a grayscale value is replicated, and
+     * kept unclamped). False — `out` untouched — outside the frame or for a
+     * missing pixel. A packed frame always reads as RGB.
+     */
+    rgb(x: number, y: number, out: number[]): boolean;
+    /**
+     * `w` pixels of row `y` from column `x0`, as opaque RGBA into `dst` from
+     * offset `o`. Missing pixels become opaque black.
+     */
+    rgbaRow(y: number, x0: number, w: number, dst: Uint8ClampedArray, o: number): void;
+}
+/** The accessor for `frame`; `isGrayscale` describes a nested frame's cells. */
+export declare function framePixels(frame: CachedFrame | undefined, isGrayscale: boolean): FramePixels;

package/lib/toolbar/tool-kit/mask-stroke-editor.d.ts

@@ -0,0 +1,125 @@
+import { BBoxMask } from '../../geometry/raster';
+import { IRegionDataHost } from '../../contracts/coordinate-transform.contract';
+import { Polygon, Region } from '../../models/region';
+import { MatrixFrame } from './matrix-frame';
+import type { CachedImageData, CanvasToolHost } from './canvas-tool';
+/** The readback size the stroke is painted against (the rasterizer's clip window). */
+export interface StrokeImage {
+    width: number;
+    height: number;
+}
+/** Where a wand or brush pointer tick lands (see {@link MaskStrokeEditor.beginTick}). */
+export interface StrokeTick {
+    /** The host's readback. */
+    cached: CachedImageData;
+    /** The current regions, mutated by the tick and committed once. */
+    regions: Region[];
+    /** The readback's data↔matrix frame. */
+    frame: MatrixFrame;
+    /** The matrix point under the pointer, inside the readback. */
+    mx: number;
+    my: number;
+}
+/** How a commit turns traced pieces into regions. */
+export interface StrokeCommitOptions {
+    /** The tick erased (Shift): a stroke erased to nothing removes its regions. */
+    erase: boolean;
+    /** A brand-new region for a piece no existing region owns. */
+    newRegion(bounds: Polygon): Region;
+    /** Fields applied on top of an edited region (e.g. a painted class colour). */
+    editPatch?: Partial<Region>;
+    /** Class label given to an edited region that has none, so tool output is never unlabeled. */
+    defaultLabel: string;
+}
+/**
+ * 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 declare class MaskStrokeEditor {
+    /** The accumulated mask, in matrix coords of {@link frameSig}'s frame. */
+    stroke: BBoxMask | null;
+    /** Id of the region the stroke edits (null = a fresh region); for a split,
+     *  the largest piece. */
+    regionId: number | null;
+    /** Ids of the extra pieces an erase split off, reused across ticks so they
+     *  keep stable identities. */
+    private 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. */
+    private 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. */
+    private template;
+    private frameSig;
+    /** Drop the stroke and everything tied to it. */
+    reset(): void;
+    /**
+     * 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: CanvasToolHost, e: {
+        clientX: number;
+        clientY: number;
+    }): StrokeTick | null;
+    /** 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: Region[]): void;
+    /** 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: MatrixFrame): void;
+    /** True if matrix point (mx, my) is painted in the stroke. */
+    contains(mx: number, my: number): boolean;
+    /**
+     * 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: number, y0: number, x1: number, y1: number): boolean;
+    /**
+     * 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: Region[], mx: number, my: number, frame: MatrixFrame, image: StrokeImage, accept?: (r: Region) => boolean): boolean;
+    /**
+     * 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: Region[], frame: MatrixFrame, image: StrokeImage, accept?: (r: Region) => boolean): void;
+    /**
+     * 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: Region[], frame: MatrixFrame, host: IRegionDataHost, opts: StrokeCommitOptions): void;
+    /** Remove the stroke's region(s) and reset — an erase deleted every pixel. */
+    dropActive(regions: Region[], host: IRegionDataHost): void;
+    /** The region with `id` in `regions`, or the adopted/merged template when a
+     *  merge already removed it from the list. */
+    private owner;
+    /** Replace `existing` in place (or append it if a merge removed it). */
+    private upsert;
+    /** The fields an edit sets on `existing`: the tool's patch, plus a default label. */
+    private patchFor;
+    private insert;
+    /**
+     * 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).
+     */
+    private editableRing;
+}

package/lib/toolbar/tool-kit/matrix-frame.d.ts

@@ -0,0 +1,40 @@
+import type { CachedImageData } from './canvas-tool';
+/**
+ * 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 declare class MatrixFrame {
+    /** Data units per matrix column. */
+    readonly rx: number;
+    /** Data units per matrix row. */
+    readonly ry: number;
+    /** Data X of matrix column 0. */
+    readonly ox: number;
+    /** Data Y of matrix row 0. */
+    readonly oy: number;
+    private constructor();
+    /** The frame of a readback. Missing/zero ratios fall back to 1, missing origins to 0. */
+    static from(cached: Pick<CachedImageData, 'ratios' | 'originX' | 'originY'>): MatrixFrame;
+    /** Identity of the frame: a stroke built in matrix coords is only valid while this is unchanged. */
+    get sig(): string;
+    toMatrixX(x: number): number;
+    toMatrixY(y: number): number;
+    toDataX(mx: number): number;
+    toDataY(my: number): number;
+    /** A ring (parallel arrays) from data to matrix coords. */
+    ringToMatrix(xs: number[], ys: number[]): {
+        xs: number[];
+        ys: number[];
+    };
+    /** A ring (parallel arrays) from matrix to data coords. */
+    ringToData(xs: number[], ys: number[]): {
+        xs: number[];
+        ys: number[];
+    };
+    /** Hole rings (`[[x, y], …]`) from data to matrix coords. */
+    holesToMatrix(holes: number[][][] | undefined): number[][][] | undefined;
+    /** Hole rings (`[[x, y], …]`) from matrix to data coords. */
+    holesToData(holes: number[][][] | undefined): number[][][] | undefined;
+}

package/lib/toolbar/tool-kit/tool-overlay.d.ts

@@ -0,0 +1,60 @@
+/** Pointer callbacks of an on-canvas tool. */
+export interface ToolOverlayHandlers {
+    /** Primary-button press (other buttons are ignored). The pointer is captured,
+     *  so the drag keeps reporting moves and its release outside the canvas. */
+    down?(e: PointerEvent): void;
+    /** Every move, pressed or hovering. */
+    move?(e: PointerEvent): void;
+    /** Release, cancel, or leaving the canvas without a capture. */
+    up?(e: PointerEvent): void;
+    /** The canvas backing store was resized (its contents were cleared). */
+    resize?(): void;
+}
+/**
+ * The transparent canvas an on-canvas tool (wand, brush, vertex eraser,
+ * zoom-to-box, SAM point) lays over the plot to take the pointer:
+ *
+ * - absolute, 100 % of the container, above the renderer (z-index 100);
+ * - pointer events (mouse, pen, touch) with pointer capture, so a drag that
+ *   leaves the canvas keeps going instead of ending at the edge;
+ * - only the primary button starts a gesture;
+ * - a backing store sized to the container × devicePixelRatio and kept in step
+ *   by a ResizeObserver, so drawing stays sharp and aligned after a panel or
+ *   window resize (RT-31). {@link context} draws in CSS pixels.
+ */
+export declare class ToolOverlayCanvas {
+    private canvas;
+    private handlers;
+    private resizeObserver?;
+    private readonly listeners;
+    /** The overlay canvas while attached. */
+    get element(): HTMLCanvasElement | null;
+    get attached(): boolean;
+    /** Width / height in CSS pixels. */
+    get cssWidth(): number;
+    get cssHeight(): number;
+    /** Lay the canvas over `container` (no-op when already attached). */
+    attach(container: HTMLElement, handlers: ToolOverlayHandlers, cursor?: string): HTMLCanvasElement;
+    /** Remove the canvas and its listeners (no-op when detached). */
+    detach(): void;
+    /** The 2D context, scaled so drawing coordinates are CSS pixels. */
+    context(): CanvasRenderingContext2D | null;
+    /** Clear the whole canvas. */
+    clear(): void;
+    /** An event's position relative to the canvas, in CSS pixels. */
+    toLocal(e: {
+        clientX: number;
+        clientY: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    private onDown;
+    private onUp;
+    /** Leaving ends a drag only when nothing captured the pointer (a captured
+     *  drag continues outside the canvas until release). */
+    private onLeave;
+    /** Size the backing store to the container × DPR. True when it changed. */
+    private fit;
+    private dpr;
+}

package/lib/toolbar/tool-kit/undo-gesture.d.ts

@@ -0,0 +1,17 @@
+/** The part of RegionStore a tool needs to make one drag one undo step. */
+export interface UndoGestureTarget {
+    beginGesture(): void;
+    endGesture(): void;
+}
+/**
+ * Brackets one pointer drag as a single undo step on the region store (RT-12):
+ * `begin()` on pointer-down, `end()` on pointer-up/leave or deactivation.
+ * Idempotent, so every exit path can call `end()`. A no-op without a target.
+ */
+export declare class UndoGesture {
+    private readonly target;
+    private open;
+    constructor(target: UndoGestureTarget | null | undefined);
+    begin(): void;
+    end(): void;
+}

package/lib/toolbar/tool-slider/tool-slider.component.d.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A labelled toolbar slider: label, p-slider, value readout. Used for the
+ * brush size, wand sensitivity, vertex-eraser radius and the isosurface band
+ * (`range`). Presentational: the host owns the value.
+ */
+export declare class ToolSliderComponent {
+    /** The label before the slider. */
+    label: string;
+    /** A number, or `[low, high]` with {@link range}. */
+    value: number | number[];
+    /** Lower bound of the slider. */
+    min: number;
+    /** Upper bound of the slider. */
+    max: number;
+    /** Slider step. */
+    step: number;
+    /** A two-handle range slider: {@link value} is `[low, high]`. */
+    range: boolean;
+    /** Tooltip (HTML). */
+    tooltip: string;
+    /** The readout after the slider. */
+    valueText: string;
+    /** Slider moved: its value (or values with {@link range}); PrimeNG may report none. */
+    valueChange: EventEmitter<number | number[] | undefined>;
+    protected onChange(event: {
+        value?: number;
+        values?: number[];
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolSliderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolSliderComponent, "toolbar-tool-slider", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "range": { "alias": "range"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "valueText": { "alias": "valueText"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/lib/toolbar/toolbar-help-dialog/toolbar-help-dialog.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { ToolbarDialogToolContribution, ToolbarToolContribution } from '../../contracts/toolbar-tool.contract';
+import * as i0 from "@angular/core";
+/**
+ * The plotting toolbar's help dialog: static documentation of every tool, plus
+ * the help each contributed tool brings.
+ */
+export declare class ToolbarHelpDialogComponent implements OnChanges {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** Contributed no-prompt tools (their help entries are listed). */
+    contributedTools: ToolbarToolContribution[];
+    /** Contributed dialog tools (their help entries are listed). */
+    dialogTools: ToolbarDialogToolContribution[];
+    /** Contributed tool names for the prompted/no-prompt contrast, e.g.
+     *  "YOLO, Retinal layers". Empty when nothing is registered, which is why
+     *  the sentence that uses it is itself conditional. */
+    protected contributedToolNames: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarHelpDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarHelpDialogComponent, "toolbar-help-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "contributedTools": { "alias": "contributedTools"; "required": false; }; "dialogTools": { "alias": "dialogTools"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}

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

@@ -1,5 +1,4 @@
-import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
-import { MenuItem } from 'primeng/api';
+import { EventEmitter } from '@angular/core';
 import { IImageInfo } from '../contracts/image.contract';
 import { PlotType, PlotTypeId } from '../contracts/plot-type';
 import { ToolbarToolVisibility } from '../contracts/toolbar-config';
@@ -18,13 +17,13 @@ import * as i0 from "@angular/core";
  * 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 {
+export declare class ToolbarComponent {
     /** Current image (gates which control groups are shown). */
     imageInfo: IImageInfo | undefined;
     /** A spatial dataset is on offer: its plot modes are a choice even with no image loaded. */
     hasSpatialDataset: boolean;
     /** Whether the plot-type dropdown shows: for an image, or a spatial dataset with none. */
-    get showPlotTypes(): boolean;
+    protected get showPlotTypes(): boolean;
     /** Plot types the active backend advertises, then any contributed modes. */
     plotTypeOptions: PlotTypeOption[];
     /** The selector's value: a built-in type or a contributed mode's id. */
@@ -40,7 +39,9 @@ export declare class ToolbarComponent implements OnChanges {
     /** 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[];
+    /** The last slice index of a stack. */
     maxIndex: number;
+    /** The current slice (0-based). */
     zIndex: number;
     /** True for any 2D (non Surface-3D) plot type. */
     isHeatmap: boolean;
@@ -51,20 +52,21 @@ export declare class ToolbarComponent implements OnChanges {
      * controls — flipping that would show 2D pan/zoom and hide the orbit controls.
      */
     is3dRegions: boolean;
+    /** The armed tool's mode (zoom, pan, a drawing tool, `samPoint`, …), or null. */
     activeDragMode: string | null;
+    /** The 3D camera mode (`turntable` / `orbit` / …). */
     activeSurface3dMode: string;
     /** Whether the napari 3D axes/scale gizmo is currently shown (drives the toggle's look). */
     axesVisible: boolean;
+    /** The napari surface wireframe is on. */
     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;
-    }[];
+    /** Magic-wand sensitivity. */
     wandSensitivity: number;
+    /** Brush diameter in image pixels. */
     brushSize: number;
+    /** Vertex-eraser radius in image pixels. */
     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). */
@@ -72,6 +74,7 @@ export declare class ToolbarComponent implements OnChanges {
     /** Whether an undone region action is available to redo (jit-ui#85). Greys
      *  out the Redo button when false. */
     canRedo: boolean;
+    /** The single-image / stack choices of the Plotly stack toggle. */
     stackOptions: {
         name: string;
         val: string;
@@ -87,6 +90,7 @@ export declare class ToolbarComponent implements OnChanges {
         id: string;
         label: string;
     }[];
+    /** The selected SAM model id. */
     samModelId: string;
     /**
      * Tools contributed through {@link TOOLBAR_TOOLS}, already filtered to the
@@ -100,31 +104,46 @@ export declare class ToolbarComponent implements OnChanges {
     openDialogToolId: string | null;
     /** Active checkpoint per contributed tool, keyed by tool id. */
     toolModelIds: Record<string, string>;
+    /** A plot type or contributed mode was picked. */
     selectPlotType: EventEmitter<string>;
     /** 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>;
+    /** The isosurface band slider moved: the new `[low, high]` pair. */
     isoRangeChange: EventEmitter<number[] | undefined>;
     /** Open the Channels & Histogram dialog (brightness/contrast, colormap, …). */
     openChannelHistogram: EventEmitter<void>;
     /** Open the spatial-omics controls (colour-by, legend, point display). */
     openSpatialControls: EventEmitter<void>;
+    /** Open the Region Editor dialog. */
     openRegionEditor: EventEmitter<void>;
+    /** A single-image / stack choice was picked. */
     selectStackOption: EventEmitter<{
         name: string;
         val: string;
     }>;
+    /** The live slice scrubber moved (fires while dragging). */
     zScrub: EventEmitter<number | undefined>;
+    /** The live slice scrubber was released on a slice. */
     zSlide: EventEmitter<number | undefined>;
+    /** A slice number was typed. */
     zIndexInput: EventEmitter<number>;
+    /** Re-plot at the typed slice. */
     reloadAndPlot: EventEmitter<void>;
+    /** Download the current view as PNG. */
     downloadImage: EventEmitter<void>;
+    /** Fit the image to the view. */
     autoscaleImage: EventEmitter<void>;
+    /** A zoom / pan / drawing 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 coordinate-axes / scale gizmo on/off. */
     toggleAxes: EventEmitter<void>;
@@ -132,6 +151,7 @@ export declare class ToolbarComponent implements OnChanges {
     toggleWireframe: EventEmitter<void>;
     /** Change the napari 3D decimate factor (reloads at the new resolution). */
     selectResolution: EventEmitter<number>;
+    /** Delete the selected region. */
     deleteRegion: EventEmitter<void>;
     /** Undo the last region action (jit-ui#85). */
     undoRegion: EventEmitter<void>;
@@ -154,105 +174,49 @@ export declare class ToolbarComponent implements OnChanges {
     openToolParams: EventEmitter<string>;
     /** SAM model picker (jit-ui#90 P1). */
     samModelChange: EventEmitter<string>;
+    /** The wand sensitivity slider moved. */
     wandSensitivityChange: EventEmitter<number | undefined>;
+    /** The brush size slider moved. */
     brushSizeChange: EventEmitter<number | undefined>;
+    /** The vertex-eraser radius slider moved. */
     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.
-     *
-     *  `tooltip` carries the model's description from {@link MODEL_INFO}; the
-     *  menus' shared item template turns it into the hover info icon. p-menu's own
-     *  rendering ignores the field (it reads `item.title`), so it is free to use. */
-    samMenuItems: MenuItem[];
-    /**
-     * Model menus for the contributed tools, keyed by tool id. Same stable-array
-     * reasoning as {@link samMenuItems} — and it is why this is a map rebuilt in
-     * `ngOnChanges` rather than a method called from the template, which would
-     * hand `p-menu` a new array every tick.
-     *
-     * A contributed tool supplies its own per-model description, so unlike the
-     * SAM menu these do not consult {@link MODEL_INFO}: this library has no
-     * copy for checkpoints it does not know about.
-     */
-    toolMenuItems: Record<string, 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;
-    /**
-     * Strip markup from a model description so it can be read aloud.
-     *
-     * The copy in MODEL_INFO and in a contribution's `ToolModelOption.info` is
-     * written for a visual tooltip rendered with `[escape]="false"`, so it carries
-     * `<b>` and `<br>`. Passed to `aria-label` verbatim a screen reader announces
-     * the tags, so they are removed and `<br>` becomes a sentence break. Entities
-     * used in that copy (`&nbsp;`, `&times;`, `&amp;`) are decoded for the same
-     * reason.
-     */
-    plainText(html: string): string;
-    /** Contributed tool names for the help dialog's prompted/no-prompt contrast,
-     *  e.g. "YOLO, Retinal layers". Empty when nothing is registered, which is
-     *  why the sentence that uses it is itself conditional. */
-    get contributedToolNames(): string;
-    /** Keeps each contributed tool's `p-menu` overlay alive across CD ticks —
-     *  re-creating it mid-interaction swallows the click on a menu item. */
-    trackToolById(_index: number, tool: {
+    protected displayHelpDialog: boolean;
+    /** trackBy for the dialog tools' buttons. */
+    protected trackToolById(_index: number, tool: {
         id: string;
     }): string;
     /** The built-in type whose tools and controls apply to the current selection. */
-    get effectivePlotType(): PlotType;
+    protected get effectivePlotType(): PlotType;
     /** The Image plot type renders as a natively pan/zoom-able raster, so the
      *  generic zoom/pan tools are hidden. */
-    get isImageView(): boolean;
+    protected get isImageView(): boolean;
     /** Either spatial-omics mode is active, so its controls are worth offering.
      *  The 3D cloud needs the panel MORE than the 2D view does, not less: colouring,
      *  the legend and category show/hide are the only way to make sense of a
      *  million overlapping points. */
-    get isSpatialMode(): 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;
+    protected get isSpatialMode(): 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;
+    protected 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, the napari-js surface — which rebuilds the height field
      *  from the picked slice (jit-ui#102) — and the 2D spatial-omics view, where a 3D dataset's
      *  registered volume is the image and the slider picks the section whose observations are
      *  drawn. Drives the per-slice slider. */
-    get showsLiveSliceScrubber(): boolean;
+    protected 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;
+    protected get isNapariMode(): boolean;
     /** ISOSURFACE (Plotly or napari-js WebGPU, either resolution) shows the isovalue range slider. */
-    get isIsosurfaceMode(): boolean;
+    protected get isIsosurfaceMode(): boolean;
     /** The napari-js WebGPU surface — shows the wireframe toggle. */
-    get isNapariSurfaceMode(): boolean;
+    protected get isNapariSurfaceMode(): boolean;
     /** Any napari-js WebGPU 3D type (volume/isosurface/surface) — shows the Resolution control. */
-    get isNapari3dMode(): boolean;
+    protected 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;
+    protected get isIntensityCapable(): boolean;
+    protected showHelp(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "plotting-toolbar", never, { "imageInfo": { "alias": "imageInfo"; "required": false; }; "hasSpatialDataset": { "alias": "hasSpatialDataset"; "required": false; }; "plotTypeOptions": { "alias": "plotTypeOptions"; "required": false; }; "selectedPlotType": { "alias": "selectedPlotType"; "required": false; }; "basePlotType": { "alias": "basePlotType"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "is3dRegions": { "alias": "is3dRegions"; "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; }; "contributedTools": { "alias": "contributedTools"; "required": false; }; "dialogTools": { "alias": "dialogTools"; "required": false; }; "openDialogToolId": { "alias": "openDialogToolId"; "required": false; }; "toolModelIds": { "alias": "toolModelIds"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "addProfileLine": "addProfileLine"; "toggleImageSmoothing": "toggleImageSmoothing"; "isoRangeChange": "isoRangeChange"; "openChannelHistogram": "openChannelHistogram"; "openSpatialControls": "openSpatialControls"; "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"; "runTool": "runTool"; "toggleDialogTool": "toggleDialogTool"; "toolModelChange": "toolModelChange"; "openToolParams": "openToolParams"; "samModelChange": "samModelChange"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "plotting-toolbar", never, { "imageInfo": { "alias": "imageInfo"; "required": false; }; "hasSpatialDataset": { "alias": "hasSpatialDataset"; "required": false; }; "plotTypeOptions": { "alias": "plotTypeOptions"; "required": false; }; "selectedPlotType": { "alias": "selectedPlotType"; "required": false; }; "basePlotType": { "alias": "basePlotType"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "is3dRegions": { "alias": "is3dRegions"; "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; }; "contributedTools": { "alias": "contributedTools"; "required": false; }; "dialogTools": { "alias": "dialogTools"; "required": false; }; "openDialogToolId": { "alias": "openDialogToolId"; "required": false; }; "toolModelIds": { "alias": "toolModelIds"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "addProfileLine": "addProfileLine"; "toggleImageSmoothing": "toggleImageSmoothing"; "isoRangeChange": "isoRangeChange"; "openChannelHistogram": "openChannelHistogram"; "openSpatialControls": "openSpatialControls"; "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"; "runTool": "runTool"; "toggleDialogTool": "toggleDialogTool"; "toolModelChange": "toolModelChange"; "openToolParams": "openToolParams"; "samModelChange": "samModelChange"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, ["*"], true, never>;
 }