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

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

@@ -0,0 +1,82 @@
+/**
+ * A tiled region source: one image's large region set, served as level-of-detail tiles so a view
+ * never holds or draws the whole set (see `region-tiles` for the levels and tiles).
+ *
+ * Two implementations behind {@link RegionSource}: a GeoJSON source parsed and tiled in a Web
+ * Worker (`openGeoJsonRegionSource`, the main thread only ever sees tiles), and an HTTP source
+ * for a server that serves the same tiles (`openHttpRegionSource`).
+ */
+import type { ClassOutlines, GeoJsonFeatureLike, RegionIndexPage, RegionIndexQuery, RegionSourceInfo, RegionTile, RegionTileKey, TileFeature } from './region-tiles';
+import type { RegionStyle } from '../region-overlay/region-style';
+/** A feature's exact GeoJSON with the source's id for it. */
+export interface SourceFeature {
+    id: string;
+    feature: GeoJsonFeatureLike;
+}
+/** One image's tiled region set. */
+export interface RegionSource {
+    /** What the source holds; known once it is open. */
+    readonly info: RegionSourceInfo;
+    /** One tile of plane `z`. Cached: asking again for a tile in view costs nothing. */
+    getTile(z: number, key: RegionTileKey, signal?: AbortSignal): Promise<RegionTile>;
+    /** The exact features with these ids (unknown ids are skipped). */
+    getFeatures(ids: readonly string[]): Promise<SourceFeature[]>;
+    /** A page of plane `z`'s feature index. */
+    getIndex(z: number, query: RegionIndexQuery): Promise<RegionIndexPage>;
+    /**
+     * Every plane's outlines of the features of these classes, simplified for `level`, without the
+     * `exclude`d ids: what a 3D reconstruction of the classes stacks. `classes` null reads every
+     * class, each outline labelled with its own (what a section through the stack draws).
+     */
+    getClassOutlines(classes: readonly string[] | null, level: number, exclude?: readonly string[]): Promise<ClassOutlines[]>;
+    /**
+     * How many features of each class plane `z` has (null: every plane, the whole stack), without
+     * the `exclude`d ids.
+     */
+    getClassCounts(z: number | null, exclude?: readonly string[]): Promise<Record<string, number>>;
+    /**
+     * The whole set as a GeoJSON FeatureCollection string, through the working set: `exclude`d
+     * features (taken for editing, or deleted) left out, `extra` features appended.
+     */
+    exportGeoJson(exclude: readonly string[], extra: readonly object[]): Promise<string>;
+    /** Release the source (its worker table, its cache). */
+    dispose(): void;
+}
+/** What the store shows of the current slice's region source: what a source layer draws. */
+export interface RegionSourceView {
+    source: RegionSource;
+    /** The source plane the slice shows. */
+    plane: number;
+    /** Ids the source no longer draws: taken into the working set, or deleted. */
+    taken: ReadonlySet<string>;
+    /** The colour a feature is drawn in (its class colour, as a region of that class gets). */
+    colorOf(feature: Pick<TileFeature, 'label' | 'color'>): string;
+    /** The region look, the regions' own (so a feature looks the same once taken). */
+    style: RegionStyle;
+    /** Whether class labels are shown. */
+    labels: boolean;
+    /** Whether a class's features are hidden (see `RegionStore.setClassesHidden`); default: none is. */
+    isHidden?(label: string | null | undefined): boolean;
+}
+/**
+ * ROI GeoJSON at least this many characters long loads as a tiled region source rather than as
+ * regions (see `VizConfig.regionSourceMinChars`).
+ */
+export declare const REGION_SOURCE_MIN_CHARS = 1000000;
+/** Tiles a source keeps, most recently used last. */
+export declare const REGION_TILE_CACHE_SIZE = 384;
+/** A least-recently-used cache of tile requests. A request that fails is forgotten. */
+export declare class RegionTileCache {
+    private readonly limit;
+    private readonly tiles;
+    constructor(limit?: number);
+    /** The cached tile, else `load()`'s, cached. */
+    get(z: number, key: RegionTileKey, load: () => Promise<RegionTile>): Promise<RegionTile>;
+    clear(): void;
+}
+/** An `AbortError`, as `fetch` and the workers reject with. */
+export declare function abortError(): Error;
+/** True for the rejection of an aborted request. */
+export declare function isAbortError(err: unknown): boolean;
+/** `promise`, rejected with an `AbortError` as soon as `signal` fires (the work goes on). */
+export declare function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;

package/lib/region-source/region-tiles.d.ts

@@ -0,0 +1,289 @@
+/** An axis-aligned box `[x0, y0, x1, y1]` in image pixels. */
+export type Bbox = [number, number, number, number];
+/** Edge of a level-0 tile, in image pixels. */
+export declare const REGION_TILE_SIZE = 512;
+/**
+ * One class of a class hierarchy (e.g. a brain-atlas ontology): the class name the features use,
+ * its long name, its parent class and its colour. A region set may carry one (a GeoJSON
+ * FeatureCollection's `classHierarchy` member); the Region Editor then lists the set as a tree.
+ */
+export interface RegionClassNode {
+    /** The class name, as features use it (`classification.name`): an atlas acronym, say. */
+    name: string;
+    /** The long name, e.g. "Somatomotor areas, Layer 5". */
+    title?: string;
+    /** The parent class's name; absent for a root. */
+    parent?: string | null;
+    /** `#rrggbb`. */
+    color?: string;
+    /** Position among its siblings (an atlas's graph order); file order without one. */
+    order?: number;
+}
+/**
+ * How a region set wants to be drawn, a hint the viewer applies when the set opens (a GeoJSON
+ * FeatureCollection's `style` member): an atlas fills its structures and labels them.
+ */
+export interface RegionSourceStyle {
+    /** Fill regions in their colour at this opacity (0 = outlines only). */
+    fillOpacity?: number;
+    /** Outline colour when filled (default: the region's colour). */
+    stroke?: string;
+    /** Outline width in screen px. */
+    strokeWidth?: number;
+    /** Show class labels inside the regions. */
+    labels?: boolean;
+    /** Fill colour of selected regions. */
+    highlight?: string;
+}
+/** What a region source holds, known once it is open. */
+export interface RegionSourceInfo {
+    /** Features in the source, over every plane. */
+    featureCount: number;
+    /** The box around every feature's geometry; null when none has any. */
+    bounds: Bbox | null;
+    /** Edge of a level-0 tile, in image pixels. */
+    tileSize: number;
+    /** Number of levels; the last one's tiles cover {@link bounds} in a few tiles. */
+    levels: number;
+    /** The z planes features are on (QuPath's `geometry.plane.z`, 0 without one), ascending. */
+    planes: number[];
+    /** The colour the file gives each class (its first feature's), by class name. */
+    classColors: Record<string, string>;
+    /** The set's class hierarchy, when it has one. */
+    hierarchy?: RegionClassNode[];
+    /** How the set wants to be drawn, when it says. */
+    style?: RegionSourceStyle;
+}
+/** One feature as a tile carries it: identity, class and outline at the tile's level. */
+export interface TileFeature {
+    id: string;
+    /** The class name. */
+    label: string | null;
+    /** The feature's own colour (`#rrggbb`), from its classification. */
+    color: string | null;
+    /** The box around the exact geometry. */
+    bbox: Bbox;
+    /** Rings as interleaved `x, y` (no repeated closing vertex): exteriors and holes of every
+     *  part, drawn and hit-tested even-odd. For an open feature, its polylines. */
+    rings: Float32Array[];
+    /** A polyline (LineString) rather than an area. */
+    open: boolean;
+    /**
+     * Where to label the feature, per part big enough: `x, y, room` triples, `room` the distance
+     * from the point to the part's nearest edge (image px), so a label shows once it fits.
+     */
+    labels?: Float32Array;
+}
+/**
+ * A class's outlines on one plane: rings as interleaved `x, y` image px (holes included), and its
+ * open features' polylines, likewise (absent from a server that predates them). Read for every
+ * class at once, each ring's and line's class comes with it (`ringLabels`, `lineLabels`).
+ */
+export interface ClassOutlines {
+    z: number;
+    rings: Float32Array[];
+    /**
+     * The feature each ring is part of (see SliceOutlines.ringGroups): a feature's rings fill
+     * even-odd, the features as their union. Absent from a server that predates them.
+     */
+    ringGroups?: number[];
+    lines?: Float32Array[];
+    ringLabels?: string[];
+    lineLabels?: string[];
+}
+/** One tile of one level of one plane. */
+export interface RegionTile {
+    z: number;
+    level: number;
+    gx: number;
+    gy: number;
+    features: TileFeature[];
+}
+/** A tile's address. */
+export interface RegionTileKey {
+    level: number;
+    gx: number;
+    gy: number;
+}
+/** One row of a source's feature index (the Region Editor's table). */
+export interface RegionIndexRow {
+    id: string;
+    label: string | null;
+    color: string | null;
+    bbox: Bbox;
+    /** The area inside the exact outline (holes left out), image px²; 0 for a polyline. Absent from a
+     *  server that predates it. */
+    area?: number;
+}
+/** A page of a plane's feature index. */
+export interface RegionIndexPage {
+    /** Rows matching the query, over the whole plane. */
+    total: number;
+    rows: RegionIndexRow[];
+}
+/** Which rows a page of the index holds. */
+export interface RegionIndexQuery {
+    offset: number;
+    limit: number;
+    /** Only rows whose class name contains this (case-insensitive). */
+    label?: string;
+    /** Leave these ids out (taken into the working set, or deleted). */
+    exclude?: readonly string[];
+    /** Only rows of exactly these classes. */
+    classes?: readonly string[];
+}
+/** The parts of a GeoJSON feature the tiler reads. Parsed from a file: nothing is guaranteed. */
+export interface GeoJsonFeatureLike {
+    type?: string;
+    id?: string | number;
+    geometry?: {
+        type?: string;
+        coordinates?: unknown;
+        plane?: {
+            z?: number;
+        };
+    } | null;
+    properties?: {
+        id?: string | number;
+        classification?: unknown;
+    } & Record<string, unknown>;
+}
+/**
+ * The level whose tiles suit a zoom of `pxPerImagePx` screen pixels per image pixel: exact (0)
+ * at 1:1 and closer, else level k for zooms in [2⁻ᵏ, 2¹⁻ᵏ), where its tolerance is half to one
+ * screen pixel and the features it leaves out are under one or two.
+ */
+export declare function regionLevelFor(pxPerImagePx: number, levels: number): number;
+/** Simplification tolerance of a level, in image pixels (0 = exact). */
+export declare function levelTolerance(level: number): number;
+/** Features smaller than this (their box's longer side, image pixels) are left out of a level. */
+export declare function levelMinExtent(level: number): number;
+/** Tile edge of a level, in image pixels. */
+export declare function levelTileSize(level: number, tileSize?: number): number;
+/**
+ * Tiles of `level` that meet `rect`, clipped to `bounds` (none past the data), ordered from the
+ * rectangle's centre outward so the middle of the screen fills first. At most `limit`.
+ */
+export declare function regionTilesInRect(rect: Bbox, level: number, tileSize: number, bounds: Bbox | null, limit?: number): RegionTileKey[];
+/** `level/gx/gy`, a tile's id within one plane. */
+export declare function regionTileId(k: RegionTileKey): string;
+/** The tile of `level` holding image point (x, y). */
+export declare function tileAt(x: number, y: number, level: number, tileSize?: number): RegionTileKey;
+/** True when two boxes meet (edges included). */
+export declare function bboxesMeet(a: Readonly<Bbox>, b: Readonly<Bbox>): boolean;
+/**
+ * The feature under image point (x, y): inside an area (even-odd over its rings, so holes are
+ * outside) or within `tolerance` image pixels of a polyline. Of several, the one with the
+ * smallest box — the innermost of nested outlines. Null when none is.
+ */
+export declare function featureAt(features: Iterable<TileFeature>, x: number, y: number, tolerance?: number): TileFeature | null;
+/** Features whose box meets `rect` (the rubber band's rule for regions). */
+export declare function featuresInRect(features: Iterable<TileFeature>, rect: Readonly<Bbox>): TileFeature[];
+/** Even-odd containment over interleaved rings. */
+export declare function insideRings(rings: readonly ArrayLike<number>[], x: number, y: number): boolean;
+/** Douglas–Peucker over an open polyline (both ends kept). */
+export declare function simplifyPolyline(xs: number[], ys: number[], epsilon: number): {
+    xs: number[];
+    ys: number[];
+};
+/**
+ * Rings simplified for a level: every ring through Douglas–Peucker at the level's tolerance,
+ * rings whose box is under the level's minimum extent dropped, and rings left with too few
+ * vertices to draw (3 for a closed ring, 2 for a polyline) dropped. Level 0 returns the rings
+ * as they are.
+ */
+export declare function simplifyRings(rings: readonly Float64Array[], open: boolean, level: number): Float32Array[];
+/**
+ * A parsed GeoJSON region set, indexed for tiles. Holds the raw features (for the exact
+ * geometry and the export), each feature's rings, box, plane and class, and builds a level's
+ * tile buckets the first time that level of a plane is asked for.
+ */
+export declare class RegionFeatureTable {
+    readonly raw: GeoJsonFeatureLike[];
+    readonly tileSize: number;
+    readonly ids: string[];
+    readonly labels: Array<string | null>;
+    readonly colors: Array<string | null>;
+    readonly planes: number[];
+    readonly boxes: Bbox[];
+    readonly rings: Float64Array[][];
+    readonly open: boolean[];
+    /** Per feature, its parts as ring indices (the exterior first, then its holes). */
+    readonly parts: number[][][];
+    private readonly labelPoints;
+    /** Each feature's area, worked out the first time its row is asked for. */
+    private readonly areas;
+    private hierarchy?;
+    private style?;
+    private readonly byId;
+    private readonly buckets;
+    private readonly simplified;
+    private readonly bounds;
+    private readonly levels;
+    constructor(raw: GeoJsonFeatureLike[], tileSize?: number);
+    /** Parse a GeoJSON FeatureCollection string. Throws on invalid JSON or no `features`. */
+    static fromGeoJson(text: string, tileSize?: number): RegionFeatureTable;
+    /** Attach a class hierarchy and a style hint (each ignored when not well formed). */
+    describe(hierarchy?: unknown, style?: unknown): void;
+    /**
+     * The outlines of every feature of these classes, plane by plane, simplified for `level` (what a
+     * 3D reconstruction of the classes stacks), without the `exclude`d ids: closed features' rings,
+     * open features' polylines as `lines`, each ring with its feature (`ringGroups`). Planes without
+     * one are left out. `classes` null reads every labelled feature, each outline with its class
+     * (`ringLabels`, `lineLabels`).
+     */
+    classOutlines(classes: readonly string[] | null, level: number, exclude?: readonly string[]): ClassOutlines[];
+    /** Features per class on plane `z` (null: on every plane), without the `exclude`d ids. */
+    classCounts(z: number | null, exclude?: readonly string[]): Record<string, number>;
+    info(): RegionSourceInfo;
+    /** One tile of plane `z`. */
+    tile(z: number, level: number, gx: number, gy: number): RegionTile;
+    /** The raw GeoJSON features with these ids, in the order asked (unknown ids skipped). */
+    features(ids: readonly string[]): Array<{
+        id: string;
+        feature: GeoJsonFeatureLike;
+    }>;
+    /** Feature `i`'s area in px² (0 for a polyline). */
+    private areaOf;
+    /** A page of plane `z`'s features, in file order. */
+    index(z: number, query: RegionIndexQuery): RegionIndexPage;
+    /**
+     * The source as a GeoJSON FeatureCollection string, through the working set: features whose
+     * id is in `exclude` (taken for editing, or deleted) are left out, `extra` (the working set's
+     * features) appended. Every feature keeps an `id`; the set keeps its hierarchy and style.
+     */
+    exportGeoJson(exclude: readonly string[], extra: readonly object[]): string;
+    /**
+     * Feature `i`'s label points (one per part with room for a label at `level`: a part under the
+     * level's minimum extent is not drawn there), from the exact geometry, computed once.
+     */
+    private labelsAt;
+    /** Feature `i`'s rings at `level`, simplified once and cached. */
+    private ringsAt;
+    /** Entries in plane `z`'s level-`level` index: cell listings plus wide features (tests). */
+    indexEntries(z: number, level: number): number;
+    /**
+     * Plane `z`'s level-`level` index, built on first use: features by tile cell (`gx/gy` → feature
+     * indices), and the wide ones (more than {@link MAX_CELLS_PER_FEATURE} cells, or past the
+     * number range), tested against a tile when it is asked for.
+     */
+    private bucketsFor;
+}
+/**
+ * A feature spanning more tiles than this is not listed in each of them but kept aside and tested
+ * against a tile when one is asked for: one huge box (an outline around a whole slide, or a corrupt
+ * coordinate) must not make a plane's index millions of entries.
+ */
+export declare const MAX_CELLS_PER_FEATURE = 64;
+/** A feature's own id (`id`, else `properties.id`) as a string. */
+export declare function featureIdOf(feature: GeoJsonFeatureLike): string | undefined;
+/**
+ * A FeatureCollection string of `features` (each a feature's JSON), with the set's class hierarchy
+ * and style as its `classHierarchy` and `style` members when it has them: what
+ * {@link RegionFeatureTable.fromGeoJson} reads back.
+ */
+export declare function featureCollectionJson(features: readonly string[], hierarchy?: readonly RegionClassNode[], style?: RegionSourceStyle): string;
+/** A well-formed class hierarchy from a file (colours as `#rrggbb` or `[r, g, b]`), else undefined. */
+export declare function readHierarchy(raw: unknown): RegionClassNode[] | undefined;
+/** A well-formed style hint from a file, else undefined. */
+export declare function readStyle(raw: unknown): RegionSourceStyle | undefined;

package/lib/region-source/worker-region-source.d.ts

@@ -0,0 +1,65 @@
+/**
+ * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.
+ *
+ * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker
+ * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself
+ * there from its text (which the host holds anyway: it handed it over) and carries on — whether
+ * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).
+ */
+import { RegionSource } from './region-source';
+import { RegionSourceRequest, RegionSourceResults } from './region-source-ops';
+import type { ReconstructOptions, SliceOutlines } from '../geometry/reconstruct';
+import type { Mesh } from 'napari-js/geometry';
+/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */
+export type RegionSourceWorkerFactory = () => Worker | Promise<Worker>;
+/** Owns the region-source worker and the calls in flight on it. */
+export declare class RegionSourceWorkerClient {
+    private readonly factory?;
+    private worker;
+    private starting;
+    private unavailable;
+    private nextId;
+    private readonly pending;
+    /** The main-thread tables, once anything runs here. */
+    private local;
+    private tables;
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects.
+     */
+    constructor(factory?: RegionSourceWorkerFactory | undefined);
+    /** Whether calls now run on the main thread. */
+    get inThread(): boolean;
+    /**
+     * Which table set calls run on: bumped when the worker is lost. A handle opened under another
+     * names a table that is gone (or, here, another source's), so its source must open again.
+     */
+    get generation(): number;
+    /** Run `request` in the worker, or here when there is none. */
+    call<R extends RegionSourceRequest>(request: R): Promise<RegionSourceResults[R['op']]>;
+    /** {@link call}, with the {@link generation} the request ran on. */
+    run<R extends RegionSourceRequest>(request: R): Promise<{
+        result: RegionSourceResults[R['op']];
+        generation: number;
+    }>;
+    /** Terminate the worker; calls in flight reject. */
+    dispose(): void;
+    private ensureWorker;
+    private startWorker;
+    private onReply;
+    /** Stop the worker for good: every later call runs here, every call in flight is lost. */
+    private lose;
+}
+/** The worker client every GeoJSON source shares. */
+export declare function sharedRegionSourceClient(): RegionSourceWorkerClient;
+/**
+ * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or
+ * a collection without `features`.
+ */
+export declare function openGeoJsonRegionSource(text: string, client?: RegionSourceWorkerClient): Promise<RegionSource>;
+/**
+ * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),
+ * meshed in the region-source worker (on the main thread where there is none).
+ */
+export declare function reconstructInWorker(slices: readonly SliceOutlines[], options?: ReconstructOptions, client?: RegionSourceWorkerClient): Promise<Mesh>;

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

@@ -11,6 +11,10 @@ import { IVisualizer, LoadedImage, PixelData, IntensityProfile, IIsosurfaceContr
 import { SpatialDataPort } from './contracts/ports/spatial-data.port';
 import { CanvasToolOptions, ColormapNode, IBrushOptions, IWandOptions } from './contracts/display-types';
 import { RegionStore } from './store/region-store.service';
+import { RegionSource, RegionSourceView } from './region-source/region-source';
+import type { RegionIndexPage, RegionIndexQuery } from './region-source/region-tiles';
+import type { RegionStyle } from './region-overlay/region-style';
+import type { RegionSourceOpener, RegionSourceSlices } from './store/region-source-scope';
 import { SpatialSelectionStore } from './store/spatial-selection.service';
 import { ViewerCapabilities } from './contracts/capabilities.contract';
 import { IRegionOverlay } from './contracts/region-overlay.contract';
@@ -21,7 +25,10 @@ import { NapariVisualizerService } from './implementations/napari-js/napari-visu
 import { VizConfig } from './contracts/viz-config';
 import { PlotModeViewport } from './contracts/plot-type-contribution.contract';
 import { IntensityProfileService } from './intensity/intensity-profile.service';
+import type { SectionAxis, SectionViews } from './contracts/section-view.contract';
 import * as i0 from "@angular/core";
+/** How long after the last edit the surfaces of the classes it touched are rebuilt (ms). */
+export declare const REGION_SURFACE_REBUILD_MS = 600;
 /**
  * The visualizer chain's front door: implements `IVisualizer`, `IRegionEditorApi`
  * and `IChannelHistogramApi` (bound to the `VISUALIZER` / `REGION_EDITOR_API` /
@@ -68,7 +75,55 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     private plottedFileName;
     /** The div the backends render into (every backend shares it); '' before the first plot. */
     private plotDiv;
+    /** Whether a napari volume view is the current plot type. */
+    private readonly volumeView$;
+    /** Whether the volume view's slice pane is wanted (see {@link setSliceEditor}). */
+    private readonly sliceEditor$;
+    /** Whether the volume view draws the region reconstructions through the volume. */
+    private readonly regionsThroughVolume$;
+    /** Region reconstructions built so far, by image, resolution and classes (with those classes). */
+    private readonly meshCache;
+    /** Bumped per {@link showRegionClasses3d} (and per new image), so only the latest one shows. */
+    private meshRequest;
+    /** The class groups shown in 3D, and the image they belong to. */
+    private readonly classes3d$;
+    private classes3dImage;
+    /** The groups last asked for in 3D, with their colours: what an edit's rebuild shows again. */
+    private shown3d;
+    /**
+     * Each class's fingerprint on the live slice (see classSignatures), which image and slice, and
+     * what the region sources hold (see RegionStore.getSourceStateKey). Null while nothing follows
+     * the edits (no surface built, no sections).
+     */
+    private liveClasses;
+    /** The pending rebuild of the surfaces an edit touched. */
+    private rebuildTimer;
+    private readonly regionUpdates;
+    /** The div the slice pane renders into while it is wanted (null: no split). */
+    private sliceDiv;
+    /** Whether OSD is mounted in the slice pane: region, tool and overlay calls go to it. */
+    private sliceMounted;
+    /** The image the slice pane shows. */
+    private sliceFile;
+    /** Bumped per slice-pane mount or teardown, so only the latest one lands. */
+    private sliceRequest;
+    /** The sections beside the split volume view (the planes x and y through the stack). */
+    private readonly sections;
+    /** The z plane dragged in the volume: the slice to show (see {@link getSliceDrag$}). */
+    private readonly sliceDrag$;
+    private readonly sectionSubs;
+    /** The image info and screen height of the last plot (what the slice pane mounts). */
+    private plottedInfo;
+    private plottedHeight;
     constructor(plotly: PlotlyService, osd: OpenSeadragonVisualizerService, napari: NapariVisualizerService, store: VisualizerStore, config: VizConfig, regionStore: RegionStore, selectionStore: SpatialSelectionStore, intensity: IntensityProfileService, spatialData?: SpatialDataPort | null);
+    /** A class's colour: its classification colour, else its region source's, else a default. */
+    private classColor;
+    /** The sections beside the split volume view (nulls while it is not split). */
+    getSectionViews$(): Observable<SectionViews>;
+    /** Move a section's plane to `at` (image px). */
+    setSectionPlane(axis: SectionAxis, at: number): void;
+    /** The slice picked by dragging the z plane in the volume: the host shows it (its slider). */
+    getSliceDrag$(): Observable<number>;
     private isImageType;
     /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain
      *  (OSD, then Plotly).
@@ -92,11 +147,27 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     private imageBackend;
     /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */
     private renderer;
+    /**
+     * Backend region, tool and overlay calls act on: the slice pane's OSD while the volume view is
+     * split (regions are edited there), else the backend on screen. View calls (zoom, fit, colour,
+     * export) stay with {@link renderer}.
+     */
+    private regionBackend;
     get capabilities(): ViewerCapabilities;
     load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<LoadedImage>;
     /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */
     private loadViaOsdThenPlotly;
     plot(plotDiv: string, imageLoaded: unknown, imageInfo: IImageInfo, screenHeight: number, plotType: PlotType, inPlace?: boolean): Promise<boolean>;
+    /**
+     * Split the volume view: show the slice being edited in `div` (OpenSeadragon, with every region
+     * tool) beside the 3D view, or stop (null). Kept across re-plots of a volume view; another plot
+     * type takes the pane down and a volume view brings it back. Resolves whether the pane shows.
+     */
+    setSliceEditor(div: string | null): Promise<boolean>;
+    /** Mount (or refresh in place) OSD in the slice pane on the displayed slice. */
+    private mountSlice;
+    /** Take the slice pane's viewer down (the split stays wanted while {@link sliceDiv} is set). */
+    private unmountSlice;
     reloadAndPlot(): void;
     reset(): void;
     relayout(trueImageSize?: number[]): void;
@@ -190,9 +261,74 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     /** Download `regions` as GeoJSON, named after the image last plotted. */
     exportRegions(regions: Region[]): void;
     getGeoJsonString(regions: Region[]): string;
+    /** Hold a large region set as a tiled region source (see RegionStore.attachRegionSource). */
+    attachRegionSource(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;
+    importRegionSource(geoJsonStr: string): Promise<boolean>;
+    dropRegionSource(): Promise<void>;
+    getRegionSourceView$(): Observable<RegionSourceView | null>;
+    getRegionSourceIndex(query: Omit<RegionIndexQuery, 'exclude'>): Promise<RegionIndexPage>;
+    selectSourceFeatures(ids: readonly string[], additive?: boolean): Promise<number[]>;
+    deleteSourceFeatures(ids: readonly string[]): void;
+    getRegionStyle$(): Observable<RegionStyle>;
+    setRegionStyle(patch: Partial<RegionStyle>): void;
+    /** Whether a napari volume (or isosurface) view is on screen: regions can be shown in 3D. */
+    getVolumeView$(): Observable<boolean>;
+    /** Whether the volume view's slice pane is wanted (it shows while a volume view is on screen). */
+    getSliceEditor$(): Observable<boolean>;
+    /** Whether the volume view draws the region reconstructions through the volume. */
+    getRegionsThroughVolume$(): Observable<boolean>;
+    /**
+     * Draw the region reconstructions through the volume (it hides none of them: surfaces inside its
+     * bright structures, an OCT's layer boundaries) or hidden behind what it shows (the default).
+     */
+    setRegionsThroughVolume(through: boolean): void;
+    /** The class groups shown in 3D on this image ([] after a switch to another image). */
+    getRegionClasses3d$(): Observable<ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+    }>>;
+    /** Hide every region surface and forget them (a build still running is dropped). */
+    private clearRegionClasses3d;
+    /** Highlight the surfaces of these group keys in the volume view (none: all as usual). */
+    highlightRegionClasses3d(keys: readonly string[]): void;
+    /** A surface clicked in the volume view with the selection tool (its group key), or none (null). */
+    getRegionPicked3d$(): Observable<{
+        key: string | null;
+        additive: boolean;
+    }>;
+    /**
+     * Show these groups of classes in the volume view as 3D reconstructions (each group one surface
+     * in its colour: an atlas structure with its substructures), and only these; [] hides them.
+     * Reconstructed from every slice's outlines at the volume's resolution, cached per image.
+     */
+    showRegionClasses3d(groups: ReadonlyArray<{
+        key: string;
+        classes: readonly string[];
+        color: string;
+        label?: string;
+    }>): Promise<void>;
+    /**
+     * The regions changed: when the live slice's regions of some classes did (an edit, an undo, not
+     * a slice or image switch), their reconstructions are stale. They are dropped, and those shown
+     * in 3D are rebuilt once the edits pause.
+     */
+    private onRegionsChanged;
+    /** Fingerprint the live slice's classes, unless already: what the next edit is compared with. */
+    private trackLiveClasses;
+    /** Which slice of which image the live regions are. */
+    private liveSliceKey;
+    /** Each class's volume over the whole stack, in px² × slices (see RegionStore.classVolumes). */
+    getClassVolumes(classes: readonly string[]): Promise<Record<string, number>>;
+    getRegionSourceClassCounts(stack?: boolean): Promise<Record<string, number>>;
+    getHiddenClasses$(): Observable<ReadonlySet<string>>;
+    setClassesHidden(classes: readonly string[], hidden: boolean): void;
+    selectRegionClasses(classes: readonly string[], additive?: boolean): Promise<void>;
+    getGeoJsonStringWithSource(regions: Region[], slice?: number): Promise<string>;
     enterStackMode(slices: Map<number, Region[]>, initialZ?: number, saveLayout?: 'combined' | 'per-slice-file'): void;
     exitStackMode(): void;
     isStackMode(): boolean;
+    /** The slice the regions are shown for (recorded outside stack mode too). */
+    getDisplaySlice(): number;
     getStackSaveLayout(): 'combined' | 'per-slice-file';
     setDisplaySlice(z: number): void;
     getSliceRegions(): Region[];
@@ -261,7 +397,8 @@ export declare class RoutingVisualizerService implements IVisualizer, IRegionEdi
     getInvert$(): Observable<boolean>;
     setInvert(on: boolean): void;
     /**
-     * The active backend's region overlay. Falls back to Plotly's when the active backend
+     * The active backend's region overlay (the slice pane's while the volume view is split). 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.
      */