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

package/lib/routing-visualizer.service.d.ts

@@ -0,0 +1,227 @@
+import { Observable } from 'rxjs';
+import { Image } from 'image-js';
+import { IImageInfo, IImageMetadata } from './contracts/image.contract';
+import { Region } from './models/region';
+import { ClassPreset, PresetSet } from './models/class-preset';
+import { PlotlyService } from './implementations/plotly/plotly.service';
+import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
+import { PlotType, PlotTypeDescriptor } from './contracts/plot-type';
+import { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls } from './contracts/visualizer.contract';
+import { ViewerCapabilities } from './contracts/capabilities.contract';
+import { IRegionOverlay } from './contracts/region-overlay.contract';
+import { IRegionEditorApi } from './contracts/region-editor-api.contract';
+import { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';
+import { VisualizerStore } from './store/visualizer-store.service';
+import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
+import { VizConfig } from './contracts/viz-config';
+import * as i0 from "@angular/core";
+export declare class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi {
+    private plotly;
+    private osd;
+    private napari;
+    private store;
+    private config;
+    private currentPlotType;
+    private lastRendered;
+    /** OSD failed for the *current* render cycle (e.g. a fresh file still caching
+     *  past the deadline) → fall back to Plotly for this image only. Reset by
+     *  reset() at the start of every render cycle, so the next file — or a
+     *  re-select once the file is cached — retries OSD. (Was a permanent flag,
+     *  which left the whole session stuck on Plotly after one slow load.) */
+    private osdFellBack;
+    /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).
+     *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */
+    private napariFellBack;
+    constructor(plotly: PlotlyService, osd: OpenSeadragonVisualizerService, napari: NapariVisualizerService, store: VisualizerStore, config: VizConfig);
+    private isImageType;
+    /** The 2D napari types (image + region-centroid scatter) — a 2D fallback chain (OSD, then Plotly). */
+    private isNapariImageType;
+    /** The 3D napari types (volume/isosurface, either resolution) — no 2D fallback exists (OSD is
+     *  image-only), so they fall straight to Plotly. */
+    private isNapari3dType;
+    /**
+     * Backend to attempt for the current plot type this render. The fallback chains below are
+     * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the
+     * backend `plot()` selects (no load/plot backend mismatch):
+     *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.
+     *  - plain `IMAGE` (no opt-in): OSD → Plotly.
+     *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).
+     */
+    private imageBackend;
+    /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */
+    private renderer;
+    get capabilities(): ViewerCapabilities;
+    load(imageInfo: IImageInfo, zIndex: number): Promise<any>;
+    /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */
+    private loadViaOsdThenPlotly;
+    plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number, plotType: PlotType, inPlace?: boolean): Promise<boolean>;
+    reloadAndPlot(): void;
+    reset(): void;
+    relayout(trueImageSize?: number[]): void;
+    resetAxes(): void;
+    autoscale(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    setDragMode(mode: string | false): void;
+    setNavigatorVisible(visible: boolean): void;
+    setImageSmoothingEnabled(enabled: boolean): void;
+    setShowStack(showstack: boolean): void;
+    setZIndex(zIndex: number): void;
+    getTrueImageSize(): {
+        width: number;
+        height: number;
+    } | null;
+    getCurrentImage(): Promise<Image | null>;
+    getDisplayedPixelData(): PixelData | null;
+    getDisplayedSourceRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    downloadImage(): void;
+    exportComposite(): void;
+    setPlotType(plotType: PlotType): void;
+    setSurfaceDragMode(mode: string): void;
+    resetSurfaceCamera(): void;
+    setResolutionScale(scale: number): void;
+    getResolutionScale(): number;
+    getPlotTypeDescriptors(): PlotTypeDescriptor[];
+    setStackLoading(b: boolean): void;
+    cancelLoading(): void;
+    isStackLoading(): Observable<boolean>;
+    getStackLoadingProgress(): Observable<number>;
+    getAutoscaleEvent(): Observable<any>;
+    getIntensityProfile$(): Observable<IntensityProfile[]>;
+    renderIntensityInset(divId: string, profiles: IntensityProfile[]): void;
+    setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string, append?: boolean): void;
+    getRegions(): Region[];
+    getRegionPolygons(): any[];
+    getRegionUpdateEvent(): Observable<any[]>;
+    setSelectedShapeIndices(indices: number[]): void;
+    selectRegion(region: Region): void;
+    getSelectedShapeIndices$(): Observable<number[]>;
+    deleteActiveShape(): void;
+    getShowShapeLabel(): boolean;
+    getShapeColor(): string;
+    getFillColor(): string;
+    getClassificationColors(): Map<string, string>;
+    setClassificationColor(label: string, color: string): void;
+    getPresetSet(): PresetSet;
+    getPresetSet$(): Observable<PresetSet>;
+    setPresetSet(set: PresetSet): void;
+    upsertClass(preset: ClassPreset): void;
+    removeClass(name: string): void;
+    resetPresets(): void;
+    plotPreviousShapes(): void;
+    setPreviousShapes(shapes: any[]): void;
+    getPreviousShapes(): any[];
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getCanUndo$(): Observable<boolean>;
+    getCanRedo$(): Observable<boolean>;
+    resetUndoHistory(): void;
+    importRegions(geoJsonStr: string): Region[];
+    exportRegions(regions: Region[]): void;
+    getGeoJsonString(regions: Region[]): string;
+    enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: 'combined' | 'per-slice-file'): void;
+    exitStackMode(): void;
+    isStackMode(): boolean;
+    getStackSaveLayout(): 'combined' | 'per-slice-file';
+    setDisplaySlice(z: number): void;
+    getSliceRegions(): Region[];
+    getStackSaveSlices(): Map<number, Region[]>;
+    /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged
+     *  with its zero-based Region.z; profile lines excluded. Flat annotation set
+     *  outside stack mode. */
+    getSliceAnnotationRegions(): Region[];
+    /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):
+     *  slice index → that slice's annotation regions (profile lines excluded),
+     *  including now-empty slices that were loaded non-empty (so they overwrite). */
+    getStackSaveAnnotationSlices(): Map<number, Region[]>;
+    /** Authoritative full-resolution image size for mask export. Prefers the
+     *  active renderer's reported size, falling back to the image metadata (x/y
+     *  are the full-res pixel dimensions used across the app). Rejects non-finite
+     *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is
+     *  fully laid out, which would otherwise crash mask creation. */
+    getMaskImageSize(): {
+        width: number;
+        height: number;
+    } | null;
+    getAnnotationRegions(): Region[];
+    setAnnotationRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string): void;
+    getSelectedRegions$(): Observable<Region[]>;
+    setSelectedRegions(regions: Region[]): void;
+    setWandMode(active: boolean, options?: any): void;
+    setWandOptions(options: any): void;
+    clearActiveWandRegion(): void;
+    setBrushMode(active: boolean, options?: any): void;
+    setBrushOptions(options: any): void;
+    setVertexEraserMode(active: boolean): void;
+    setVertexEraserRadius(radius: number): void;
+    setZoomToBoxMode(active: boolean): void;
+    segmentRectangles(): Promise<number>;
+    segmentRectanglesCellpose(): Promise<number>;
+    setSamModel(id: string): void;
+    setSamPointMode(active: boolean): void;
+    commitSamPoints(): void;
+    clearSamPoints(): void;
+    getColormap(): Observable<any>;
+    setColormap(colormap: any): void;
+    getColormapOptions(): any;
+    getReverseScale(): Observable<boolean>;
+    setReverseScale(reverscale: any): void;
+    setImageMeta(imageMeta: IImageMetadata[]): void;
+    getImageMeta(): Observable<IImageMetadata[]>;
+    getHistogram(channelIndex: number, bins: number): IHistogram | null;
+    getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null>;
+    /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */
+    exportData(): void;
+    getChannels$(): Observable<IChannelState[]>;
+    setChannelState(index: number, partial: Partial<IChannelState>): void;
+    resetContrast(indices: number[]): void;
+    /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each
+     *  end of its histogram (skipping outlier first/last bins). */
+    autoContrast(indices: number[], saturation: number): void;
+    getGrayscale$(): Observable<boolean>;
+    setGrayscale(on: boolean): void;
+    getInvert$(): Observable<boolean>;
+    setInvert(on: boolean): void;
+    /**
+     * The active backend's region overlay. Falls back to Plotly's when the active backend
+     * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a
+     * usable overlay.
+     */
+    getRegionOverlay(): IRegionOverlay;
+    /**
+     * Isosurface controls when available — always Plotly's, since the isosurface
+     * plot type renders on Plotly (OSD only handles the image type).
+     */
+    getIsosurfaceControls(): IIsosurfaceControls | null;
+    /** 3D scene controls — always Plotly's, since the 3D plot types render on
+     *  Plotly (OSD only handles the image type). */
+    getSurface3dControls(): ISurface3dControls | null;
+    /** Intensity (line-ROI) controls — always Plotly's, since the line profiles
+     *  render their inset on Plotly regardless of which backend draws the image. */
+    getIntensityControls(): IIntensityControls | null;
+    /** Load pixel frames for intensity sampling when OpenSeadragon owns the image
+     *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */
+    ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void>;
+    /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),
+     *  so the intensity inset can re-sample at the current zoom level. Plotly's own
+     *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */
+    getViewportChange$(): Observable<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Re-sample the intensity profiles from a fresh crop of the given image-pixel
+     *  ROI at display resolution (sampling always lives in Plotly). */
+    refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void;
+    unsubscribe(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingVisualizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoutingVisualizerService>;
+}

package/lib/store/class-color.util.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Deterministic colour engine for preset annotation classes (jit-ui#70).
+ *
+ * Resolution order for a region `label`:
+ *   1. a matching preset (exact by default, or normalized if the set's matchMode says so)
+ *      -> the preset's colour;
+ *   2. otherwise a deterministic fallback colour derived from a stable hash of the name,
+ *      so the same unknown class always gets the same colour with no stored state.
+ *
+ * These functions are pure (no mutation); opt-in promotion of unknown classes into the
+ * set is handled by the store, which owns persistence.
+ */
+import { ClassPreset, PresetSet } from '../models/class-preset';
+export declare function normalizeLabel(s: string): string;
+/** Stable, non-negative 32-bit string hash (identical across runs and machines). */
+export declare function hashString(s: string): number;
+/** Find the preset matching `label` under the set's match mode. */
+export declare function findPreset(label: string, set: PresetSet): ClassPreset | undefined;
+/**
+ * Deterministic fallback colour for an unknown class name: index into the palette by a
+ * stable hash of the (normalized) name; if the palette is empty, generate a golden-angle
+ * HSL hue. Same name -> same colour, every run.
+ */
+export declare function fallbackColorFor(label: string, palette: string[]): string;
+/** Resolve a colour for `label`: a matching preset's colour, else the deterministic fallback. */
+export declare function colorForLabel(label: string, set: PresetSet): string;

package/lib/store/region-store.service.d.ts

@@ -0,0 +1,315 @@
+import { Observable } from 'rxjs';
+import { IImageInfo } from '../contracts/image.contract';
+import { Region, Rectangle, Polygon, MultiPolygon } from '../models/region';
+import { VisualizerStore } from './visualizer-store.service';
+import { IRegionStore } from '../contracts/visualizer.contract';
+import { IRegionEditApi } from '../contracts/region-store.contract';
+import * as i0 from "@angular/core";
+/**
+ * Backend-neutral region store — the single source of truth for region state.
+ *
+ * Holds the neutral {@link Region} model (never a backend's own shape
+ * representation), keyed per image so regions persist as the user switches
+ * files and survive a Plotly⇄OpenSeadragon backend switch (both backends read
+ * and write *this* store, so no migration is needed). Backends own *rendering*
+ * and react to {@link getRegionUpdateEvent}; this service owns *state* and the
+ * editing operations.
+ *
+ * Implements:
+ *  - {@link IRegionStore} — the cross-backend CRUD/selection/colour contract
+ *    every consumer (Region Editor, segmentation, etc.) already uses.
+ *  - {@link IRegionEditApi} — Region-native geometry edits (move/resize, and
+ *    add/delete/move vertex) the OSD overlay drives.
+ *
+ * Classification colours live in {@link VisualizerStore} (shared by both
+ * backends); GeoJSON import/export and the closed-polygon projection reuse the
+ * neutral {@link PlotUtilities} helpers. All coordinates are image pixels.
+ */
+export declare class RegionStore implements IRegionStore, IRegionEditApi {
+    private store;
+    private static readonly UNDO_LIMIT;
+    private static readonly UNDO_COALESCE_MS;
+    /** Per-image region cache. `regions` is always a snapshot of the entry for
+     *  `currentImageKey`. */
+    private regionsByImageKey;
+    private currentImageKey;
+    /** The current image's regions — the live, edited array. */
+    private regions;
+    /** Last saved snapshot, restorable via plotPreviousShapes(). */
+    private previousRegions;
+    /**
+     * Undo/redo history (jit-ui#85): up to {@link UNDO_LIMIT} snapshots of the
+     * region set, each a deep clone captured immediately *before* a
+     * region-editing action. {@link undo} pops the newest off `undoStack`, pushes
+     * the current state onto `redoStack`, and restores it — so it can be invoked
+     * up to {@link UNDO_LIMIT} times in a row. {@link redo} is the mirror. Any new
+     * region action clears `redoStack` (the redo future is no longer reachable).
+     *
+     * A continuous gesture (a wand/brush/vertex drag commits to the store many
+     * times) is coalesced into a single entry: the first commit of a burst
+     * captures the pre-burst state and every commit within
+     * {@link UNDO_COALESCE_MS} of the previous one is folded into it. History
+     * never crosses an image load/switch — {@link resetUndoHistory} clears it.
+     */
+    private undoStack;
+    private redoStack;
+    /** True while a coalescing burst is open (further commits fold into it). */
+    private undoBurstOpen;
+    private undoBurstTimer;
+    /** True while restoring a snapshot, so the restore records no new history. */
+    private restoringUndo;
+    private readonly canUndo$;
+    private readonly canRedo$;
+    /** Monotonic id source — ids never repeat within the service lifetime, so
+     *  selection stays correct across delete/add cycles even when names collide. */
+    private nextId;
+    private showShapeLabel;
+    private shapeColor;
+    private fillColor;
+    private isRegionSavedOn;
+    /**
+     * Per-slice region support for z-stacks (jit-ui#93). While {@link stackMode}
+     * is on (a z-stack is loaded), the live `regions` array always holds ONE
+     * slice — the {@link currentSliceZ} slice — so the on-canvas overlays, the
+     * selection projection, and the Regions table keep working unchanged
+     * (they all read {@link getRegions}). The other slices live in
+     * {@link regionsBySlice}; {@link setDisplaySlice} swaps the live set on scrub
+     * and {@link getSliceRegions} flattens every slice (each tagged with its
+     * zero-based {@link Region.z}) for save/export. Off by default (stackMode
+     * false, z 0), so single-plane images are completely unaffected.
+     */
+    private regionsBySlice;
+    private stackMode;
+    private currentSliceZ;
+    /** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one
+     *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`
+     *  writes one geojson per slice-file (a folder of numbered images). */
+    private stackSaveLayout;
+    /** Slices that were loaded with regions (jit-ui#93). A per-slice-file save
+     *  re-writes these even when now empty, so clearing a slice's regions and
+     *  saving removes its previously-saved geojson (writes an empty one). */
+    private stackInitialNonEmpty;
+    /** Selection is tracked by region *id* internally (stable across edits) and
+     *  projected to array indices on the IRegionStore boundary. */
+    private selectedIds;
+    private readonly selectedIndices$;
+    private readonly regionUpdate$;
+    /** Non-coalesced sibling of regionUpdate$: fires on every change even during a
+     *  batched drag, so live consumers (intensity inset) update per frame. */
+    private readonly regionLiveEdit$;
+    /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
+    private batchDepth;
+    private pendingEmit;
+    private readonly plotUtilities;
+    constructor(store: VisualizerStore);
+    /**
+     * Replace (or, with `append`, add to) the current image's regions. Mints ids
+     * and default names, applies stored classification colours, and emits. When
+     * `isRegionSaveOn` is false the regions are shown transiently (emitted) but
+     * not stored — mirrors the previous Plotly behaviour.
+     */
+    setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean, fillColor?: string, append?: boolean): void;
+    /** The canonical accessor: current image's regions (live instances). */
+    getRegions(): Region[];
+    /** True while a z-stack is loaded and the store holds regions per slice. */
+    isStackMode(): boolean;
+    /** The current display slice (zero-based). */
+    getDisplaySlice(): number;
+    /** How the current stack persists to disk (jit-ui#93): `combined` = one
+     *  z-indexed geojson (single-file z-stack); `per-slice-file` = one geojson per
+     *  slice-file (folder stack). Meaningless outside stack mode. */
+    getStackSaveLayout(): 'combined' | 'per-slice-file';
+    /**
+     * Enter per-slice stack mode. `slices` maps each zero-based slice index to
+     * the regions imported for that slice; the store makes `initialZ`'s slice the
+     * live set, so the overlays / selection / Regions table are unchanged (they
+     * still read {@link getRegions}). Freshly-created regions are tagged with the
+     * current slice so they persist on it, and {@link getSliceRegions} returns
+     * every slice for save/export. Ids/names/classification colours are minted
+     * exactly as {@link setRegions} does.
+     */
+    enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: 'combined' | 'per-slice-file'): void;
+    /** Leave stack mode (single-plane image, or the stack was closed). */
+    exitStackMode(): void;
+    /**
+     * Show a different slice: capture the current slice's (possibly edited)
+     * regions back into the per-slice store, then load the target slice's regions
+     * as the live set and emit. Undo never crosses a slice. Outside stack mode
+     * this only records the requested slice index (a no-op otherwise: single-plane
+     * regions stay on the default plane — addRegion tags Region.z only in stack
+     * mode, so the recorded index is unused until a stack is entered). (jit-ui#93)
+     */
+    setDisplaySlice(z: number): void;
+    /**
+     * Every slice's regions for save/export, each tagged with its zero-based
+     * slice index in {@link Region.z}. Captures the current slice's live edits
+     * first. Returns the flat single-plane set when not in stack mode. (jit-ui#93)
+     */
+    getSliceRegions(): Region[];
+    /**
+     * Slices to write on a per-slice-file save (folder stack, jit-ui#93): every
+     * slice that currently has regions, PLUS slices that were loaded non-empty but
+     * are now empty (so their file is re-written empty, clearing a slice whose
+     * regions the user deleted). Each returned region is tagged with its z, and
+     * the current live slice is captured first. Empty outside stack mode.
+     */
+    getStackSaveSlices(): Map<number, Region[]>;
+    /** Mint ids/names + apply classification colours + tag the slice index, as
+     *  {@link setRegions} does, for regions entering the per-slice store. */
+    private normalizeSlice;
+    /**
+     * Closed polygons projected for image-processing consumers (segmentation,
+     * trace builders). Open polylines are annotation-only and excluded. Reuses
+     * the neutral PlotUtilities projection so output matches the previous path.
+     */
+    getRegionPolygons(): any[];
+    getRegionUpdateEvent(): Observable<any[]>;
+    /** Live (non-coalesced) region-change stream — fires per frame during a drag.
+     *  Used by the intensity-profile inset so it tracks line ROIs live. */
+    getRegionLiveEdit$(): Observable<Region[]>;
+    /** Select regions by array index (or [] to clear). Stored internally by id
+     *  so the selection survives subsequent edits/reorders. */
+    setSelectedShapeIndices(indices: number[]): void;
+    /** Select a single region by identity (id). Backends call this from their
+     *  `selectRegion()`; the OSD overlay + region editor highlight off the
+     *  resulting selection emit. No-op if the region isn't in the store. */
+    selectRegion(region: Region): void;
+    getSelectedShapeIndices$(): Observable<number[]>;
+    /** Synchronous current selection (array indices) — for callers that need to
+     *  read the selection without subscribing. */
+    getSelectedShapeIndices(): number[];
+    /** Delete the currently selected regions and clear the selection. */
+    deleteActiveShape(): void;
+    getShowShapeLabel(): boolean;
+    getShapeColor(): string;
+    getFillColor(): string;
+    /** Convenience setters (not on the contract) for toolbar wiring. */
+    setShowShapeLabel(show: boolean): void;
+    setShapeColor(color: string): void;
+    setFillColor(color: string): void;
+    getClassificationColors(): Map<string, string>;
+    setClassificationColor(label: string, color: string): void;
+    /** Re-show the last saved snapshot (transient — does not alter stored state). */
+    plotPreviousShapes(): void;
+    setPreviousShapes(shapes: any[]): void;
+    getPreviousShapes(): any[];
+    /** Emits whether an undo step is currently available — drives the toolbar
+     *  Undo button's enabled state (greyed out when false). */
+    getCanUndo$(): Observable<boolean>;
+    /** Emits whether a redo step is currently available — drives the toolbar
+     *  Redo button's enabled state. */
+    getCanRedo$(): Observable<boolean>;
+    /** Synchronous read of {@link getCanUndo$} — true when at least one region
+     *  action can be undone. */
+    canUndo(): boolean;
+    /** Synchronous read of {@link getCanRedo$} — true when an undone action can
+     *  be re-applied. */
+    canRedo(): boolean;
+    /**
+     * Undo the most recent region action, restoring the region set to its state
+     * just before that action and pushing the current state onto the redo stack.
+     * Up to {@link UNDO_LIMIT} steps are retained, so this can be called up to
+     * {@link UNDO_LIMIT} times in a row before the history empties. No-op when
+     * nothing is left to undo.
+     */
+    undo(): void;
+    /**
+     * Redo the action most recently undone, restoring the region set to the state
+     * it had before that undo and pushing the current state back onto the undo
+     * stack. No-op when there's nothing to redo (the redo stack is cleared by any
+     * fresh region action).
+     */
+    redo(): void;
+    /** Discard the undo/redo history (e.g. on image load/switch — history never
+     *  crosses images). */
+    resetUndoHistory(): void;
+    /** Make `snapshot` the live region set and notify both backends. Shared by
+     *  {@link undo} and {@link redo}; the snapshot is already a detached deep
+     *  clone, so it becomes the live array directly. */
+    private restoreSnapshot;
+    /**
+     * Capture the pre-action region set into the bounded undo history. Called at
+     * the top of every mutating operation, *before* it changes `regions`, so the
+     * snapshot is the state to return to. Rapid commits from one gesture coalesce
+     * into a single entry (see {@link undoStack}). A fresh action also abandons
+     * any redo future.
+     */
+    private recordUndoSnapshot;
+    /** Push the current can-undo / can-redo availability to subscribers. */
+    private emitUndoState;
+    /** (Re)arm the idle timer that closes the current coalescing burst. */
+    private armUndoBurst;
+    private closeUndoBurst;
+    private cloneRegions;
+    /** Deep clone a region so an in-place geometry edit can't mutate a stored
+     *  history snapshot (bounds are cloned via {@link cloneBounds}). */
+    private cloneRegion;
+    importRegions(geoJsonStr: string): Region[];
+    exportRegions(regions: Region[]): void;
+    getGeoJsonString(regions: Region[]): string;
+    addRegion(region: Region): number;
+    removeRegion(id: number): void;
+    updateBounds(id: number, bounds: Rectangle | Polygon | MultiPolygon): void;
+    moveRegion(id: number, dx: number, dy: number): void;
+    /** Translate a polygon's vertices and any holes in place by (dx, dy). */
+    private translatePolygon;
+    moveVertex(id: number, index: number, x: number, y: number): void;
+    /** Move a vertex on a polygon's interior ring (hole) — jit-ui#85. */
+    moveHoleVertex(id: number, holeIndex: number, index: number, x: number, y: number): void;
+    /** Insert a vertex on a polygon's interior ring (hole), after `segIndex`
+     *  (the edge's start vertex). No-op for an out-of-range hole — jit-ui#85. */
+    addHoleVertex(id: number, holeIndex: number, segIndex: number, x: number, y: number): void;
+    /** Delete the vertex at `index` on a polygon's interior ring (hole). Removing
+     *  it below 3 vertices drops the whole hole (a ring with < 3 points bounds no
+     *  area) — jit-ui#85. */
+    deleteHoleVertex(id: number, holeIndex: number, index: number): void;
+    addVertex(id: number, segIndex: number, x: number, y: number): void;
+    deleteVertex(id: number, index: number): void;
+    setBezier(id: number, bezier: boolean): void;
+    /** Turn bezier on (and seed editable handles from the smooth default) or off
+     *  (and drop the handles). */
+    private applyBezier;
+    /** (Re)seed per-hole bezier handles from the Catmull-Rom default, parallel to `poly.holes`. */
+    private seedHoleHandles;
+    /** Drag a bezier control point on a hole ring vertex (donut bezier editing). */
+    moveHoleBezierHandle(id: number, holeIndex: number, index: number, side: 'in' | 'out', x: number, y: number): void;
+    moveBezierHandle(id: number, index: number, side: 'in' | 'out', x: number, y: number): void;
+    beginBatch(): void;
+    endBatch(): void;
+    /**
+     * Switch the active image: snapshot the outgoing regions, restore the
+     * incoming image's (or [] if none), clear selection, and notify. Idempotent
+     * for the same image (so repeated replots of one image keep its regions).
+     */
+    setActiveImage(imageInfo: IImageInfo): void;
+    /** Drop the entire per-image cache (logout / project switch). */
+    clearRegionsByImageKey(): void;
+    private deriveImageKey;
+    /**
+     * Resolve each region's colour from the annotation-class preset set (jit-ui#70).
+     * The presets are the source of truth for colour — this **overrides any colour
+     * embedded in the GeoJSON** (which the YOLO worker writes today). A matching
+     * preset gives the class colour; an unknown class gets a deterministic fallback
+     * colour (and, only when `autoPromote` is on, is added to the editable list).
+     * Regions the user explicitly recoloured (`colorOverridden`) are left untouched.
+     */
+    private applyClassificationColors;
+    private syncCache;
+    private emit;
+    /** Project selected ids to current array indices, pruning ids that no longer
+     *  exist, and emit if the index set changed. */
+    private emitSelection;
+    private indicesEqual;
+    private findById;
+    private indexOfId;
+    /** The region's bounds as a Polygon, or undefined if it isn't a polygon. */
+    private polygonOf;
+    private clonePolygon;
+    private cloneBounds;
+    private regionsEqual;
+    private polygonsEqual;
+    /** Compare two polygons' interior-ring (hole) sets for the dedupe path. */
+    private holesEqual;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegionStore>;
+}