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

package/lib/section-pane/section-pane.component.d.ts

@@ -0,0 +1,47 @@
+import { AfterViewInit, EventEmitter, NgZone, OnChanges, OnDestroy } from '@angular/core';
+import type { SectionAxis, SectionView } from '../contracts/section-view.contract';
+import * as i0 from "@angular/core";
+export declare class SectionPaneComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly zone;
+    axis: SectionAxis;
+    view: SectionView | null;
+    /** A point clicked, in section coordinates (u across, v down). */
+    readonly pick: EventEmitter<{
+        u: number;
+        v: number;
+    }>;
+    private canvasRef;
+    private zoom;
+    private pan;
+    private press;
+    private image;
+    private resize?;
+    private frame;
+    constructor(zone: NgZone);
+    protected get axisColor(): string;
+    protected get label(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    /** Back to the whole section, centred. */
+    fit(): void;
+    protected onWheel(e: WheelEvent): void;
+    protected onDown(e: PointerEvent): void;
+    protected onMove(e: PointerEvent): void;
+    protected onUp(e: PointerEvent): void;
+    private local;
+    /** Section units → CSS px in the pane: scale per unit across and down, and the origin. */
+    private transform;
+    private toSection;
+    /** Redraw on the next frame (outside Angular: a canvas paint needs no change detection). */
+    private draw;
+    private paint;
+    /** Each class's cut: its outlines filled and stroked, its lines drawn (a dot for one point). */
+    private paintRegions;
+    /** The other planes: across (u) and down (v), dashed in their axis colours. */
+    private paintCrosshair;
+    /** The section's image on a canvas of its own size (made again only for a new image). */
+    private imageCanvas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionPaneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionPaneComponent, "viz-section-pane", never, { "axis": { "alias": "axis"; "required": true; }; "view": { "alias": "view"; "required": false; }; }, { "pick": "pick"; }, never, never, true, never>;
+}

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

@@ -30,7 +30,10 @@ export declare function findPreset(label: string, set: PresetSet): ClassPreset |
  * 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. */
+/**
+ * Resolve a colour for `label`: a matching preset's colour, else the colour an imported file
+ * gave the class, else the deterministic fallback.
+ */
 export declare function colorForLabel(label: string, set: PresetSet): string;
 /** Options for {@link applyPresetColors}. */
 export interface ApplyPresetColorsOptions {
@@ -49,8 +52,8 @@ export interface ApplyPresetColorsOptions {
 /**
  * Resolve each labelled region's colour from the preset set (jit-ui#70). The
  * presets are the source of truth: a matching preset gives the class colour,
- * an unknown class its deterministic fallback, **overriding any colour already
- * on the region** (e.g. embedded in imported GeoJSON). Unlabelled regions and
+ * an unknown class the colour an imported file gave it (`importedColors`) or else
+ * its deterministic fallback, **overriding any colour already on the region**. Unlabelled regions and
  * ones the user recoloured (`colorOverridden`) are left untouched. Unknown
  * classes are reported through `onPromote` when `autoPromote` is on.
  *

package/lib/store/class-signatures.d.ts

@@ -0,0 +1,11 @@
+import { Region } from '../models/region';
+/**
+ * A fingerprint of each class's regions (by label): their ids and geometry folded into one number
+ * per class. Two sets give the same fingerprint for a class when its regions did not change, so
+ * comparing a slice's fingerprints before and after an edit names the classes the edit touched
+ * (a recoloured or relabelled region touches its old class and its new one). Profile lines and
+ * unlabelled regions are left out: they are in no class.
+ */
+export declare function classSignatures(regions: readonly Region[]): Map<string, number>;
+/** The classes whose fingerprints differ between `before` and `after` (added and removed included). */
+export declare function changedClasses(before: ReadonlyMap<string, number>, after: ReadonlyMap<string, number>): Set<string>;

package/lib/store/region-scope-cache.d.ts

@@ -26,6 +26,8 @@ export declare class RegionScopeCache {
     private initialNonEmpty;
     /** The cache key for an image: its first URL, else its file name. */
     static imageKey(imageInfo: IImageInfo | undefined): string | undefined;
+    /** The active image's cache key (see {@link imageKey}). */
+    get activeImage(): string | undefined;
     /** True while a z-stack is loaded and regions are held per slice. */
     get stackMode(): boolean;
     /** The current display slice (zero-based; 0 outside stack mode unless set). */

package/lib/store/region-source-scope.d.ts

@@ -0,0 +1,68 @@
+import type { RegionSource } from '../region-source/region-source';
+/** Opens a region source on demand (and again after it was closed to save memory). */
+export type RegionSourceOpener = () => Promise<RegionSource>;
+/** Which slices a source serves: one slice (plane `plane` of the source), or every slice z
+ *  from the source's plane z (a z-indexed GeoJSON over a whole stack). */
+export type RegionSourceSlices = {
+    slice: number;
+    plane?: number;
+} | 'planes';
+/** The region source behind one slice: the source and which of its planes the slice shows. */
+export interface RegionSourceBinding {
+    source: RegionSource;
+    plane: number;
+}
+/** Sources held open, past which the least recently used one is closed (never the one shown). */
+export declare const OPEN_REGION_SOURCES = 6;
+/**
+ * The region sources of every image the store has seen, per slice, and per slice the ids of
+ * the source features taken out of the source (into the working set, or deleted) — those the
+ * source no longer draws and an export leaves out.
+ *
+ * Sources open lazily, the first time their slice is shown or read, and at most
+ * {@link OPEN_REGION_SOURCES} stay open: the least recently used are closed and re-opened from
+ * their opener when used again (a source's ids are stable, so what was taken stays taken). The
+ * source of the slice on screen ({@link show}) is never closed for another: a read across every
+ * slice must not close the source the viewer draws and takes from.
+ */
+export declare class RegionSourceScope {
+    private readonly images;
+    /** Open entries, least recently used first. */
+    private readonly openOrder;
+    /** The entry of the slice on screen: kept open. */
+    private shown;
+    /** Attach `open` to `image` for `slices`, replacing (and closing) what was there. */
+    attach(image: string, open: RegionSourceOpener, slices: RegionSourceSlices): void;
+    /** Drop every source of `image` (closing the open ones) and what was taken from them. */
+    detachImage(image: string): void;
+    /** Drop the source of one slice of `image`. */
+    detachSlice(image: string, slice: number): void;
+    /** The slice on screen (null: none): its source stays open while others are read. */
+    show(image: string | undefined, slice: number | null): void;
+    /** Whether `image` has a source for `slice`. */
+    has(image: string | undefined, slice: number): boolean;
+    /** Whether `slice` of `image` has a source of its own (not a `'planes'` source's plane). */
+    hasOwnSource(image: string | undefined, slice: number): boolean;
+    /** Every slice of `image` with a source of its own (not counting a `'planes'` source). */
+    slicesWithSource(image: string | undefined): number[];
+    /** Whether `image` has one source over all its slices. */
+    hasPlanesSource(image: string | undefined): boolean;
+    /**
+     * The source behind `slice` of `image`, opening it if needed. Resolves null when there is
+     * none, and rejects when it cannot be opened.
+     */
+    binding(image: string | undefined, slice: number): Promise<RegionSourceBinding | null>;
+    /** The ids taken from `slice`'s source. */
+    taken(image: string | undefined, slice: number): ReadonlySet<string>;
+    /** Every id taken from any slice of `image` (a `'planes'` source's ids are unique across them). */
+    allTaken(image: string | undefined): string[];
+    /** The slices of `image` with anything taken from their source. */
+    slicesWithTaken(image: string | undefined): number[];
+    /** Replace the ids taken from `slice`'s source (copy-on-write: `ids` is kept as given). */
+    setTaken(image: string | undefined, slice: number, ids: ReadonlySet<string>): void;
+    private entry;
+    private imageSources;
+    private openEntry;
+    private close;
+    private closeSource;
+}

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

@@ -3,9 +3,17 @@ 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 { IRegionEditApi, IRegionSourceApi } from '../contracts/region-store.contract';
+import type { Mesh } from 'napari-js/geometry';
+import { SliceOutlines } from '../geometry/reconstruct';
 import { StackSaveLayout } from './region-scope-cache';
+import { RegionSourceOpener, RegionSourceSlices } from './region-source-scope';
+import type { RegionSource, RegionSourceView } from '../region-source/region-source';
+import type { RegionIndexPage, RegionIndexQuery } from '../region-source/region-tiles';
+import { RegionStyle } from '../region-overlay/region-style';
 import * as i0 from "@angular/core";
+/** Selecting classes takes at most this many region-source features into the regions. */
+export declare const SELECT_CLASSES_LIMIT = 5000;
 /**
  * Backend-neutral region store — the single source of truth for region state.
  *
@@ -34,7 +42,7 @@ import * as i0 from "@angular/core";
  * backends); GeoJSON import/export is `models/region-geojson`. All coordinates
  * are image pixels.
  */
-export declare class RegionStore implements IRegionStore, IRegionEditApi {
+export declare class RegionStore implements IRegionStore, IRegionEditApi, IRegionSourceApi {
     private store;
     private static readonly UNDO_LIMIT;
     private static readonly UNDO_COALESCE_MS;
@@ -78,6 +86,35 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     /** Emit coalescing for live drags (see IRegionEditApi.beginBatch). */
     private batchDepth;
     private pendingEmit;
+    /**
+     * Large region sets held as tiled region sources rather than as regions (see
+     * {@link attachRegionSource}): per image and slice, with the ids taken out of each.
+     */
+    private readonly sources;
+    private readonly sourceView$;
+    /** The region look the user chose (overrides the source's hint), field by field. */
+    private userStyle;
+    /** The current source's style hint. */
+    private hintStyle;
+    private readonly regionStyle$;
+    /** Bumped on every change of the slice's source, so a late open is dropped. */
+    private sourceGeneration;
+    /** The source last published as the view: a source shown again does not turn the labels back on. */
+    private shownSource;
+    /** Bumped when a region source is attached or dropped: what is read from the sources is stale. */
+    private sourcesVersion;
+    /**
+     * The region sources' part of {@link classVolumes}, by class and what the sources hold (see
+     * {@link sourceStateKey}): an edit of the regions leaves it, so the volumes of a slice being drawn
+     * on cost no source reads.
+     */
+    private readonly sourceVolumeCache;
+    /** The region sources' outlines of the class sets reconstructed last (see {@link sourceOutlines}). */
+    private readonly sourceOutlineCache;
+    /** The classes hidden from view (names as given); every class is shown at first. */
+    private readonly hiddenClasses$;
+    /** {@link hiddenClasses$} by {@link presetKey}, as a region's label is matched. */
+    private hiddenKeys;
     constructor(store: VisualizerStore);
     /**
      * Replace (or, with `append`, add to) the current image's regions. Mints ids
@@ -236,6 +273,10 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
      * region it edits) rather than changing them, so it never changes after this.
      */
     private recordUndoSnapshot;
+    /** The state an undo step restores. */
+    private snapshot;
+    /** Parse GeoJSON into regions, remembering the class colours the file carries so they are
+     *  kept for classes with no preset (see VisualizerStore.rememberImportedClassColors). */
     importRegions(geoJsonStr: string): Region[];
     /** Download `regions` as GeoJSON, named after `fileName` (extension
      *  replaced by `.geojson`) or `rois.geojson` without one. */
@@ -286,6 +327,169 @@ export declare class RegionStore implements IRegionStore, IRegionEditApi {
     beginGesture(): void;
     /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */
     endGesture(): void;
+    /**
+     * Hold a large region set as a tiled region source instead of as regions: the backends that
+     * draw sources (OpenSeadragon, napari) draw its features at the detail the zoom shows, from
+     * the tiles in view, and a feature joins the regions — exactly, as an ordinary editable
+     * {@link Region} with its {@link Region.sourceId} — only when it is selected or edited
+     * ({@link takeSourceFeatures}). Until then {@link getRegions} does not include it.
+     *
+     * `source` may be an opener, called the first time its slice is shown (and again if the
+     * source was closed to save memory). `slices` says which slice of the current image it
+     * serves: one (default: the slice shown; plane 0 of the source), or `'planes'`, every slice z
+     * from plane z of a z-indexed source. Replaces the source those slices had.
+     */
+    attachRegionSource(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;
+    /** Drop the current image's region sources (closing them) and what was taken from them. */
+    detachRegionSources(): void;
+    /**
+     * Drop the slice's region source, for regions imported in place of the slice's (a small file
+     * replacing a large one): a source of the slice's own is detached; a z-indexed source over every
+     * slice has this slice's features taken out (as deleted). The other slices keep theirs.
+     */
+    dropSliceRegionSource(): Promise<void>;
+    /** Whether the slice shown has a region source. */
+    hasRegionSource(): boolean;
+    /** The slice's region source as a source layer draws it; null without one (or until it opens). */
+    getRegionSourceView(): RegionSourceView | null;
+    /** {@link getRegionSourceView} and every change of it (slice, taken ids, class colours). */
+    getRegionSourceView$(): Observable<RegionSourceView | null>;
+    /**
+     * Take source features into the working set for editing: their exact geometry becomes
+     * ordinary regions (minted, coloured and slice-tagged as any region entering the store) and
+     * the source stops drawing them. Not an undo step of its own — undoing past it puts the
+     * features back in the source. Resolves the region ids, in the order asked (a feature already
+     * taken resolves to its region); [] when the slice changed meanwhile.
+     */
+    takeSourceFeatures(ids: readonly string[]): Promise<number[]>;
+    /** {@link takeSourceFeatures}, then select them (added to the selection with `additive`). */
+    selectSourceFeatures(ids: readonly string[], additive?: boolean): Promise<number[]>;
+    /**
+     * Features per class still in the slice's region source (not taken); {} without one. With
+     * `stack`, a z-stack's over every slice: its source's planes, or each slice's source added up.
+     */
+    getRegionSourceClassCounts(stack?: boolean): Promise<Record<string, number>>;
+    /**
+     * Select every region of these classes on the slice — the regions', and the region source's,
+     * which are taken into the regions (at most {@link SELECT_CLASSES_LIMIT} of them). Added to the
+     * selection with `additive`. Resolves the selected region ids.
+     */
+    selectClasses(classes: readonly string[], additive?: boolean): Promise<number[]>;
+    /**
+     * The 3D reconstruction of each group of classes over every slice of the stack (an atlas
+     * structure with its substructures, say): the outlines of the regions of those classes on every
+     * slice — the region sources' and those drawn or taken — stacked and meshed in a worker. Meshes
+     * are in image px (x, y) and slice indices (z). `pixelStep` is the in-plane voxel size (image
+     * px); the outlines are read at the matching level of detail. A group with no outline gets an
+     * empty mesh.
+     */
+    reconstructClasses(groups: ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+    }>, pixelStep?: number): Promise<Array<{
+        key: string;
+        mesh: Mesh;
+    }>>;
+    /**
+     * Each class's volume over the whole stack, in px² × slices: its outlines' area on every slice
+     * (its features' union, see `outlinesArea`), one slice thick (Cavalieri's estimator), from the
+     * exact outlines. Where a feature is, a region source's or a drawn or taken region, does not
+     * change it: taking one leaves the volume as it was. The region sources' part is cached until
+     * what they hold changes (a feature taken or deleted, another source); only the slices with
+     * drawn or taken regions of the class are measured again.
+     */
+    classVolumes(classes: readonly string[]): Promise<Map<string, number>>;
+    /** The region sources' part of a class's volume, cached by what they hold (see classVolumes). */
+    private sourceVolume;
+    /**
+     * Every slice's outlines of these classes, the region sources' then the regions': closed shapes'
+     * rings, and open polylines as `lines`.
+     */
+    private classOutlines;
+    /**
+     * The region sources' outlines of these classes on every slice, without the features taken or
+     * deleted. The last few class sets are kept until what the sources hold changes: rebuilding a
+     * surface after an edit reads nothing again.
+     */
+    private sourceOutlines;
+    private readSourceOutlines;
+    /**
+     * Every class's outlines on every slice, by class: the region sources' (one read for all, kept
+     * like {@link sourceOutlines}) and the drawn and taken regions'. What a section through the
+     * stack cuts (see `geometry/section`).
+     */
+    outlinesByClass(level: number): Promise<Map<string, SliceOutlines[]>>;
+    /** The drawn and taken regions' outlines of these classes, by slice. */
+    private regionOutlines;
+    /** Each drawn or taken region's outlines (of the `wanted` classes; null: every class) with its class. */
+    private labelledRegionOutlines;
+    /** What the region sources of the image hold (see {@link sourceStateKey}): it changes when a
+     *  feature is taken or deleted, or that is undone. */
+    getSourceStateKey(): string;
+    /**
+     * What the region sources of the image hold: the image, its sources (one attached or dropped
+     * bumps the version) and the features taken from them. A key for what is read from them.
+     */
+    private sourceStateKey;
+    /** Delete source features without taking them (one undo step). */
+    deleteSourceFeatures(ids: readonly string[]): void;
+    /**
+     * A page of the slice source's features not taken from it (file order), e.g. for the Region
+     * Editor's list; an empty page without a source.
+     */
+    getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage>;
+    /**
+     * `regions` as a GeoJSON FeatureCollection string merged with the region source behind them:
+     * the source's features that were not taken (or deleted), then `regions`. Without a source,
+     * {@link getGeoJsonString}. `slice` names a folder stack's slice (default the one shown);
+     * on a z-indexed stack's source (`'planes'`) the export spans every slice.
+     */
+    getGeoJsonWithSource(regions: Region[], slice?: number): Promise<string>;
+    /**
+     * Whether a region of class `label` goes unlabelled because a subclass of it (by the region
+     * source's class hierarchy) is among the regions too — an atlas's "Isocortex" under its areas.
+     * False without a hierarchy.
+     */
+    isLabelCovered(label: string | undefined): boolean;
+    private coveredFor;
+    /** The classes hidden from view (see {@link setClassesHidden}). */
+    getHiddenClasses(): ReadonlySet<string>;
+    /** {@link getHiddenClasses} and every change of it. */
+    getHiddenClasses$(): Observable<ReadonlySet<string>>;
+    /**
+     * Hide (or show again) these classes' regions: the overlays and the region source's layer stop
+     * drawing them, and a hidden region can be neither picked nor kept selected. The regions stay in
+     * the set (the table lists them; a save keeps them).
+     */
+    setClassesHidden(classes: readonly string[], hidden: boolean): void;
+    /** Whether regions labelled `label` are hidden (an unlabelled region never is). */
+    isClassHidden(label: string | null | undefined): boolean;
+    /** The region look: outlines, or filled (an atlas's look); see `region-style`. */
+    getRegionStyle(): RegionStyle;
+    /** {@link getRegionStyle} and every change of it. */
+    getRegionStyle$(): Observable<RegionStyle>;
+    /**
+     * Choose the region look, field by field; it overrides a region source's hint for the session.
+     * The overlays redraw.
+     */
+    setRegionStyle(patch: Partial<RegionStyle>): void;
+    /** The look now: the user's choice, else the source's hint, else outlines. */
+    private effectiveStyle;
+    /** Publish the look when it changed: the overlays redraw the regions, the source layer its features. */
+    private restyle;
+    /** Re-emit the source view with the current look and label setting. */
+    private republishView;
+    /** The slice a region source is keyed by: the display slice in stack mode, else 0. */
+    private get sourceSlice();
+    private currentTaken;
+    /** Replace the slice's taken ids and tell the source layers. */
+    private setTaken;
+    /**
+     * Look up (opening it if needed) the slice's source and publish it as the source view. The view
+     * is withdrawn at once: until the incoming source opens, nothing reads, takes or deletes from the
+     * outgoing one into the slice now shown.
+     */
+    private refreshSourceView;
     /**
      * Switch the active image: snapshot the outgoing regions, restore the
      * incoming image's (or [] if none), clear selection, and notify. Idempotent

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

@@ -36,6 +36,8 @@ export declare class VisualizerStore {
     private readonly grayscale$;
     private readonly invert$;
     private presetSet;
+    /** Session-only class colours from imported files (see PresetSet.importedColors). */
+    private importedColors;
     private readonly presetSet$;
     private readonly savePresets$;
     private presetsLoaded;
@@ -46,6 +48,8 @@ export declare class VisualizerStore {
     private readonly spatialView$;
     constructor(prefsPort?: PreferencesPort | null);
     private initPresetPersistence;
+    /** Publish the preset set with this session's imported class colours. */
+    private emitPresetSet;
     private normalizePresetSet;
     /** Queue a debounced save. No-ops until the initial load resolves (and when no port is bound). */
     private queuePresetSave;
@@ -114,6 +118,12 @@ export declare class VisualizerStore {
     /** Upsert a single class colour (used by the editor's per-class colour picker). */
     setClassificationColor(label: string, color: string): void;
     getPresetSet(): PresetSet;
+    /**
+     * Remember the class colours an imported file carried (label → colour), so its regions keep
+     * them: a class with a preset keeps the preset's colour, and the latest import wins for the
+     * rest. Not persisted.
+     */
+    rememberImportedClassColors(colors: ReadonlyMap<string, string>): void;
     getPresetSet$(): Observable<PresetSet>;
     setPresetSet(set: PresetSet): void;
     /** Add or update a class (keyed by exact stored `name`). */

package/lib/toolbar/region-tools/region-tools.component.d.ts

@@ -12,6 +12,8 @@ export declare class RegionToolsComponent {
     activeDragMode: string | null;
     /** The 3D cloud's screen-space lasso: no brush or polyline. */
     is3dRegions: boolean;
+    /** Only the selection tool (a volume view: it picks the regions' surfaces in 3D). */
+    selectOnly: boolean;
     /** The backend has a vertex-editing overlay (OSD + napari-js image). */
     vertexTools: boolean;
     /** Magic-wand sensitivity (the wand's slider value). */
@@ -56,5 +58,5 @@ export declare class RegionToolsComponent {
     /** A single slider's value (a range slider never feeds these). */
     protected asNumber(v: number | number[] | undefined): number | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionToolsComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RegionToolsComponent, "toolbar-region-tools", never, { "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "is3dRegions": { "alias": "is3dRegions"; "required": false; }; "vertexTools": { "alias": "vertexTools"; "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; }; }, { "openRegionEditor": "openRegionEditor"; "toggleDragMode": "toggleDragMode"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "deleteRegion": "deleteRegion"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionToolsComponent, "toolbar-region-tools", never, { "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "is3dRegions": { "alias": "is3dRegions"; "required": false; }; "selectOnly": { "alias": "selectOnly"; "required": false; }; "vertexTools": { "alias": "vertexTools"; "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; }; }, { "openRegionEditor": "openRegionEditor"; "toggleDragMode": "toggleDragMode"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "deleteRegion": "deleteRegion"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { EventEmitter } from '@angular/core';
+import { EventEmitter, OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
 /** A stack-mode choice (`val` 'false' = single image, 'true' = stack). */
 export interface StackOption {
@@ -6,11 +6,11 @@ export interface StackOption {
     val: string;
 }
 /**
- * The toolbar's z-stack group: a live slice scrubber for the views that swap
- * slices in place, or (Plotly heatmap) the single-image / stack toggle with a
- * slice-number field. Presentational: the host owns `zIndex`.
+ * The toolbar's z-stack group: the slice bar, and (Plotly heatmap) the single-image / stack
+ * toggle. The views that swap slices in place follow the bar as it moves; the heatmap's single
+ * image is re-plotted at the slice it settles on. Presentational: the host owns `zIndex`.
  */
-export declare class StackControlsComponent {
+export declare class StackControlsComponent implements OnDestroy {
     /** Show the live slice scrubber. */
     liveScrubber: boolean;
     /** Show the single-image / stack toggle (Plotly heatmap). */
@@ -29,12 +29,23 @@ export declare class StackControlsComponent {
     zSlide: EventEmitter<number | undefined>;
     /** A stack-mode choice was picked. */
     selectStackOption: EventEmitter<StackOption>;
-    /** A slice number was typed (blank reports the current slice). */
+    /** The heatmap's slice bar moved to a slice (the host shows its number). */
     zIndexInput: EventEmitter<number>;
-    /** Enter in the slice field / the reload button: re-plot at the typed slice. */
+    /** The heatmap's slice bar settled: re-plot at that slice. */
     reloadAndPlot: EventEmitter<void>;
-    /** The slice field reports what was typed (blank keeps the current slice). */
-    protected onSliceInput(value: string | number | null): void;
+    /** How long key steps on the heatmap's bar pause before the slice is re-plotted. */
+    static readonly REPLOT_DELAY_MS = 400;
+    /** A drag of the bar is under way (its end re-plots the heatmap, not each step). */
+    protected dragging: boolean;
+    private replot;
+    /** The heatmap in single-image mode: its bar re-plots the slice it settles on. */
+    protected get singleImage(): boolean;
+    /** The bar moved: a live view follows it; the heatmap shows the number, and re-plots after key steps pause. */
+    protected onSliceChange(z: number | undefined): void;
+    /** The bar was let go (a drag's end, or a click on its track). */
+    protected onSliceEnd(z: number | undefined): void;
+    private cancelReplot;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StackControlsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<StackControlsComponent, "toolbar-stack-controls", never, { "liveScrubber": { "alias": "liveScrubber"; "required": false; }; "stackToggle": { "alias": "stackToggle"; "required": false; }; "showStack": { "alias": "showStack"; "required": false; }; "stackOptions": { "alias": "stackOptions"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; }, { "zScrub": "zScrub"; "zSlide": "zSlide"; "selectStackOption": "selectStackOption"; "zIndexInput": "zIndexInput"; "reloadAndPlot": "reloadAndPlot"; }, never, never, true, never>;
 }

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

@@ -52,6 +52,10 @@ export declare class ToolbarComponent {
      * controls — flipping that would show 2D pan/zoom and hide the orbit controls.
      */
     is3dRegions: boolean;
+    /** A napari volume / isosurface view: the Region Editor (regions in 3D) without drawing tools. */
+    isVolumeView: boolean;
+    /** Whether the volume view is split with the slice editor (the slice, with every region tool). */
+    sliceEditor: boolean;
     /** The armed tool's mode (zoom, pan, a drawing tool, `samPoint`, …), or null. */
     activeDragMode: string | null;
     /** The 3D camera mode (`turntable` / `orbit` / …). */
@@ -118,6 +122,8 @@ export declare class ToolbarComponent {
     openSpatialControls: EventEmitter<void>;
     /** Open the Region Editor dialog. */
     openRegionEditor: EventEmitter<void>;
+    /** Split the volume view with the slice editor, or close it. */
+    toggleSliceEditor: EventEmitter<void>;
     /** A single-image / stack choice was picked. */
     selectStackOption: EventEmitter<{
         name: string;
@@ -202,7 +208,8 @@ export declare class ToolbarComponent {
      *  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. */
+     *  drawn. Also a split volume view, whose slice editor shows the slice picked. Drives the
+     *  per-slice slider. */
     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). */
@@ -218,5 +225,5 @@ export declare class ToolbarComponent {
     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, ["*"], true, 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; }; "isVolumeView": { "alias": "isVolumeView"; "required": false; }; "sliceEditor": { "alias": "sliceEditor"; "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"; "toggleSliceEditor": "toggleSliceEditor"; "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>;
 }

package/lib/visualizer/region-load.d.ts

@@ -1,7 +1,18 @@
+import type { HttpClient } from '@angular/common/http';
 import { IImageInfo } from '../contracts/image.contract';
 import { IRegionStore } from '../contracts/visualizer.contract';
-/** The region-store members {@link applyImageRois} writes through. */
-export type RegionLoadTarget = Pick<IRegionStore, 'importRegions' | 'enterStackMode' | 'setRegions' | 'resetUndoHistory'>;
+import { RegionSource } from '../region-source/region-source';
+import type { RegionSourceOpener, RegionSourceSlices } from '../store/region-source-scope';
+/** The region-store members {@link applyImageRois} writes through. A target without
+ *  `attachRegionSource` loads every ROI file as regions. */
+export type RegionLoadTarget = Pick<IRegionStore, 'importRegions' | 'enterStackMode' | 'setRegions' | 'resetUndoHistory'> & {
+    attachRegionSource?(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;
+    /** The slice shown now (what a stack's source, laid out once it opens, makes live). */
+    getDisplaySlice?(): number;
+    /** Record the slice shown (outside stack mode it only records it): see {@link applyImageRois}. */
+    setDisplaySlice?(z: number): void;
+    isStackMode?(): boolean;
+};
 /**
  * Apply an image's saved ROIs once its render has landed, choosing the region
  * layout from the image's shape:
@@ -22,6 +33,14 @@ export type RegionLoadTarget = Pick<IRegionStore, 'importRegions' | 'enterStackM
  *    Loading saved ROIs is not a user edit, so the undo history starts fresh and the
  *    first undo cannot wipe them (jit-ui#85).
  *
- * `z` is the slice shown now; entering stack mode makes it live and resets undo.
+ * Large ROI files (`minSourceChars` and up) and a server-side source (`regionSourceUrl`)
+ * become tiled region sources instead of regions; a z-indexed one serves each slice its own
+ * plane. On a single-file stack the source is opened first, to tell which: one on the default
+ * plane only stays global, as its regions would. A folder stack's sources open lazily, the first
+ * time their slice is shown.
+ *
+ * `z` is the slice shown now; entering stack mode makes it live and resets undo. `http`, the
+ * host's `HttpClient`, carries a server-side source's requests, so the host's interceptors (its
+ * auth) apply to them as to the image tiles.
  */
-export declare function applyImageRois(info: IImageInfo, target: RegionLoadTarget, z: number): void;
+export declare function applyImageRois(info: IImageInfo, target: RegionLoadTarget, z: number, minSourceChars?: number, http?: HttpClient): void;