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

package/lib/region-editor/region-editor.component.d.ts

@@ -5,20 +5,12 @@ import { ConfirmationService, MessageService } from 'primeng/api';
 import { IRegionEditorApi } from '../contracts/region-editor-api.contract';
 import { RegionPersistenceService } from './region-persistence.service';
 import { ClassColorEdit } from './region-color-dialog/region-color-dialog.component';
+import { ClassTreePick } from './class-tree/class-tree.component';
+import type { RegionSourceView } from '../region-source/region-source';
+import type { RegionClassNode } from '../region-source/region-tiles';
 import { MaskExportService, MaskMode } from './mask-export.service';
 import { PixelSize } from './region-metrics';
 import * as i0 from "@angular/core";
-/**
- * The Region Editor (`<region-editor>`): the table of the active image's
- * annotation regions with class presets, colours, labels, GeoJSON import /
- * export / server save and mask export. Self-contained: it talks to the viewer
- * only through {@link REGION_EDITOR_API} (and the host's REGION_IO_PORT), so it
- * has no inputs or outputs.
- *
- * OnPush: template events re-render it; state that lands asynchronously (the
- * API's region / selection / preset / image-meta streams, save and mask-export
- * progress, file reads) marks it for check.
- */
 export declare class RegionEditorComponent implements OnInit, OnDestroy {
     private regionApi;
     private messageService;
@@ -26,6 +18,14 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     private persistence;
     private maskExport;
     private overlayPanel;
+    /**
+     * Whether the editor is on screen (its dialog open). Closed, it asks the region source nothing:
+     * its page of features, its class counts and, in a volume view, its classes' volumes are each a
+     * request over the whole set (a stack's every slice), and they competed with the volume's own
+     * slice loading for nothing anyone could see. Opened, it reads them again.
+     */
+    set active(value: boolean);
+    private isActive;
     protected regions: Region[];
     protected selectedRegions: Region[];
     protected showShapeLabel: boolean;
@@ -62,6 +62,56 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
      *  avoids needing a unique id field. */
     protected editingLabelRegions: Map<Region, string>;
     protected showSaveAsDialog: boolean;
+    /**
+     * The slice's region source (a large region set drawn by level of detail), or null. Its
+     * features are rows of the table after the regions — stand-ins until one is selected or edited,
+     * which takes it into the regions — and its classes count in the classes panel.
+     */
+    protected sourceView: RegionSourceView | null;
+    /** Features still in the source (the table's rows after the regions). */
+    private sourceTotal;
+    /** Stand-in rows for the source features on the current page. */
+    private sourceRows;
+    /** Features per class still in the source. */
+    private sourceClassCounts;
+    /** The stand-in rows (rows of a source feature, not of a region). */
+    private readonly standIns;
+    private standInSeq;
+    /** Bumped per source refresh, so a late answer is dropped. */
+    private sourceRequest;
+    /** The classes the table's Class column offers: the presets and the region source's classes
+     *  (a dropdown can only show a value that is one of its options). */
+    protected tablePresetSet: PresetSet;
+    /** Whether regions are drawn filled (the atlas look) rather than outlined. */
+    protected regionsFilled: boolean;
+    /** Whether a volume view is on screen (classes can then be shown in 3D). */
+    protected volumeView: boolean;
+    /** Whether the volume view's slice pane is wanted (one slice edited beside the 3D view). */
+    private slicePane;
+    /** Whether the volume view draws the regions through the volume (see toggleThroughVolume). */
+    protected regionsThroughVolume: boolean;
+    /** Classes shown in 3D in the volume view, each with the classes its surface covers. */
+    protected shown3d: Map<string, string[]>;
+    /** The classes of the class tree's pick (it and its subtree), as long as the pick holds. */
+    private pickedClasses;
+    /** The selected rows' classes, marked in the class lists. */
+    protected markedClasses: ReadonlySet<string>;
+    /** The surfaces highlighted in the volume view (their keys, joined). */
+    private highlighted3d;
+    /** The colour each shown surface was last drawn in. */
+    private colors3d;
+    /** Their names, for the class lists' toggles (a new set per change, for OnPush). */
+    protected shown3dNames: ReadonlySet<string>;
+    /** The classes hidden from view (their regions, source features and surfaces). */
+    protected hiddenClasses: ReadonlySet<string>;
+    /** Whether a region set's class hierarchy is shown as a tree (rather than the class list). */
+    protected classTreeView: boolean;
+    /** The class picked last in the class tree. */
+    protected pickedClass: string | null;
+    /** Regions per class (the regions' and the source's), for the class tree. */
+    protected treeCounts: Map<string, number>;
+    /** A class's colour, for the class tree: a new function per colour change, so the tree repaints. */
+    protected treeColor: (name: string) => string;
     protected saveAsFilename: string;
     protected saveAsFileExists: boolean;
     /** True while a GeoJSON persist is serializing/uploading — drives the dialog's
@@ -115,6 +165,52 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
      * intensity-profile lines the editor never sees).
      */
     protected onSelectionChanged(): void;
+    /** Whether the slice has a region source: it then has regions to save even with an empty table. */
+    protected get hasRegionSource(): boolean;
+    /** Rows in the table: the regions, then the features still in the region source. */
+    protected get tableTotal(): number;
+    /** The class hierarchy of the slice's region source, when it has one (the classes as a tree). */
+    protected get classHierarchy(): RegionClassNode[] | null;
+    /** Whether `row` is a region-source feature's stand-in rather than a region. */
+    protected isSourceRow(row: Region): boolean;
+    private sourceIds;
+    /** A table row for a source feature: no geometry until it is taken. */
+    private standIn;
+    /**
+     * Re-read the source part of the table (the stand-ins on the current page, the count) and the
+     * source's class counts. The page holds regions first, so its source rows start at
+     * `max(first, regions)` − regions.
+     */
+    private refreshSource;
+    /** Take a source row's feature into the regions, then run `then` on the region it became. */
+    private takeThen;
+    /** Toggle the filled (atlas) look: each region filled in its colour, labels inside. */
+    /** In a volume view: the regions drawn through the volume, or hidden behind what it shows. */
+    protected toggleThroughVolume(): void;
+    protected toggleFill(): void;
+    /**
+     * Show or hide a class in the volume view as a 3D reconstruction — a tree node with every class
+     * under it, as one surface in its colour.
+     */
+    protected toggleClass3d(name: string, classes?: string[]): void;
+    /** Hide (or show again) these classes' regions, wherever they are drawn. */
+    protected setClassesHidden(classes: readonly string[], hidden: boolean): void;
+    /** The surfaces shown in 3D, in their classes' colours now. */
+    private groups3d;
+    /** The classes selected now: the class tree's pick (with its subtree) and the selected rows'. */
+    private selectedClassNames;
+    /**
+     * Highlight, in the volume view, the surfaces holding a selected class (focus + context: they
+     * turn near opaque, the others fade), and mark the selected rows' classes in the class lists.
+     */
+    private updateSelectionHighlight;
+    /** A surface clicked in the volume view: pick its class as the tree would; beside them, clear. */
+    private onPicked3d;
+    /** A class colour changed (its swatch, or Manage): repaint the surfaces shown in 3D whose colour it changed. */
+    private recolor3d;
+    private show3d;
+    /** Pick a class in the class tree: select its regions and its subclasses', the source's taken. */
+    protected pickClasses(pick: ClassTreePick): Promise<void>;
     /**
      * Rows for regions coming from the visualizer: neutral `Region`s with bounds,
      * colour and label already populated. A region without a colour is shown with
@@ -154,16 +250,26 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     /** The current page of the table. Memoized on (regions, first, rows), so
      *  change detection doesn't hand p-table a new array every tick (RT-20). */
     protected get pagedRegions(): Region[];
+    /** In a volume view, each class's volume over the whole stack, for the table (null: areas). */
+    protected tableVolumes: ReadonlyMap<string, number | null> | null;
+    /** Bumped when the regions change, so a volume computed before is dropped. */
+    private volumeRequest;
+    /** Compute the volumes of the classes on the table's page that are not known yet. */
+    private requestVolumes;
+    /** The regions changed (or the view did): forget the volumes and compute the page's again. */
+    private resetVolumes;
     private _pageKey;
     private _page;
     protected onPageChange(event: {
         first?: number;
         rows?: number;
     }): void;
-    /** Select every region in the table (and highlight them on the diagram). */
-    protected selectAllRegions(): void;
+    /** Select every region in the table (and highlight them on the diagram), the source's taken. */
+    protected selectAllRegions(): Promise<void>;
     protected deleteSelectedRegions(): void;
     protected clearAllRegions(): void;
+    /** Delete every feature still in the slice's region source (with "Delete all regions"). */
+    private deleteAllSourceFeatures;
     protected deleteRegion(shapeIdx: number): void;
     private clampPaginatorFirst;
     protected changeShowShapeLabel(showLabel: boolean): void;
@@ -198,9 +304,15 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
      * labels are ignored. (jit-ui#70)
      */
     private syncClassesFromRegions;
-    /** Rebuild the per-class region counts shown in the panel. */
+    /**
+     * Whether the classes count every slice of the stack: in a volume view (the whole stack on
+     * screen), unless its slice pane shows one slice. The table lists the slice's regions anyway.
+     */
+    private get stackCounts();
+    /** Rebuild the per-class region counts shown in the panel (the stack's, see stackCounts). */
     private recomputeClassCounts;
-    /** Rebuild the panel's display order — most-used classes first, then by name. */
+    /** Rebuild the panel's display order — most-used classes first, then by name. A class only
+     *  the region source has is listed too, in its colour. */
     private updateDisplayClasses;
     /** Number of regions currently using a class (keyed by the active match mode). */
     protected classCount(name: string): number;
@@ -237,7 +349,11 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     /** Validate and apply an imported annotation-classes JSON file. */
     private applyImportedPresets;
     protected importRois(event: Event): void;
-    /** Replace the regions with an imported GeoJSON file's. */
+    /**
+     * Replace the regions with an imported GeoJSON file's, and the slice's region source with them.
+     * A large file becomes the slice's region source instead (drawn by level of detail; listed above
+     * the table), the table emptied.
+     */
     private applyImportedRois;
     /** Regions to serialize on save/export (every slice for a combined z-stack). */
     private regionsForSave;
@@ -268,5 +384,5 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     protected cancelSaveAs(): void;
     private toast;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorComponent, "region-editor", never, {}, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorComponent, "region-editor", never, { "active": { "alias": "active"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/region-editor/region-metrics.d.ts

@@ -4,6 +4,8 @@ import { IImageMetadata } from '../contracts/image.contract';
 export interface PixelSize {
     mppX?: number;
     mppY?: number;
+    /** Spacing between slices (µm), when the stack declares it. */
+    mppZ?: number;
 }
 /**
  * Choose the physical pixel size for area display from the image meta. The
@@ -24,3 +26,9 @@ export declare function regionAreaPx(region: Pick<Region, 'bounds'>): number;
  * otherwise px². Empty for a degenerate (non-positive) area.
  */
 export declare function formatArea(px: number, mpp?: PixelSize): string;
+/**
+ * A volume in px² × slices for display: mm³ (three significant digits) from 0.001 mm³, µm³ below,
+ * when the pixel size and the slice spacing are known; otherwise voxels (one pixel by one slice).
+ * Empty for a non-positive volume.
+ */
+export declare function formatVolume(pxSlices: number, mpp?: PixelSize): string;

package/lib/region-editor/region-persistence.service.d.ts

@@ -43,8 +43,14 @@ export declare class RegionPersistenceService {
      * "does not exist" and later checks keep working.
      */
     fileExists(names: Observable<string>): Observable<boolean>;
-    /** Download `regions` as a GeoJSON file named `filename`. */
-    download(regions: Region[], filename: string): void;
+    /**
+     * `regions` as GeoJSON, merged with the image's region source when it has one (the source's
+     * features that were not taken or deleted, then `regions`); `slice` names a folder stack's
+     * slice.
+     */
+    serialize(regions: Region[], slice?: number): Promise<string>;
+    /** Download `regions` (with the region source behind them) as a GeoJSON file named `filename`. */
+    download(regions: Region[], filename: string): Promise<void>;
     /**
      * Save `regions()` to the host as `filename`. Serializing is deferred one
      * tick (so a progress indicator paints before a large synchronous
@@ -56,9 +62,11 @@ export declare class RegionPersistenceService {
      * A folder stack's regions as one geojson per slice-file (jit-ui#93), each
      * serialized on the default plane (z=0): every slice-file is one plane, and
      * the loader re-derives the slice index from the file's position. Slices
-     * cleared since load are included (empty) so their file is overwritten.
+     * cleared since load are included (empty) so their file is overwritten, and so are slices
+     * whose region source lost features; a slice with a region source keeps the features still
+     * in it.
      */
-    sliceGeoJsons(): SliceGeoJson[];
+    sliceGeoJsons(): Promise<SliceGeoJson[]>;
     /** Write per-slice geojsons through the host port. */
     saveSlices(slices: SliceGeoJson[]): Observable<void>;
     /** Read the file chosen in a file input's change event as text, then call

package/lib/region-editor/region-table/region-table.component.d.ts

@@ -40,6 +40,11 @@ export declare class RegionTableComponent implements OnChanges {
     defaultColor: string;
     /** Pixel size for the area column. */
     mpp: PixelSize;
+    /**
+     * In a volume view, each class's volume over the whole stack (px² × slices; null while it is
+     * computed): the column shows the row's class volume instead of its area. Null: areas.
+     */
+    volumes: ReadonlyMap<string, number | null> | null;
     /** Rows whose label is being edited → the typed draft. A new map per start/stop. */
     labelDrafts: Map<Region, string>;
     /** A row's pencil: start editing its label. */
@@ -63,13 +68,14 @@ export declare class RegionTableComponent implements OnChanges {
     deleteRow: EventEmitter<number>;
     /** The paginator moved or changed its page size. */
     pageChange: EventEmitter<RegionPage>;
-    /** Per row of {@link page}: its class swatch colour and formatted area, derived when
-     *  an input changes instead of per check (the area walks the region's geometry). */
+    /** Per row of {@link page}: its class swatch colour and formatted area (or class volume),
+     *  derived when an input changes instead of per check (the area walks the region's geometry). */
     protected rowView: Map<Region, {
         color: string;
-        area: string;
+        measure: string;
     }>;
     ngOnChanges(): void;
+    private measure;
     private classColor;
     private area;
     protected startEdit(region: Region, event: Event): void;
@@ -79,5 +85,5 @@ export declare class RegionTableComponent implements OnChanges {
         rows?: number;
     }): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionTableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RegionTableComponent, "region-table", never, { "page": { "alias": "page"; "required": false; }; "total": { "alias": "total"; "required": false; }; "first": { "alias": "first"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "metaKey": { "alias": "metaKey"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "presetSet": { "alias": "presetSet"; "required": false; }; "defaultColor": { "alias": "defaultColor"; "required": false; }; "mpp": { "alias": "mpp"; "required": false; }; "labelDrafts": { "alias": "labelDrafts"; "required": false; }; }, { "selectionChange": "selectionChange"; "rowSelect": "rowSelect"; "labelEditStart": "labelEditStart"; "labelDraftChange": "labelDraftChange"; "labelEditStop": "labelEditStop"; "classPick": "classPick"; "deleteRow": "deleteRow"; "pageChange": "pageChange"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionTableComponent, "region-table", never, { "page": { "alias": "page"; "required": false; }; "total": { "alias": "total"; "required": false; }; "first": { "alias": "first"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "rowsPerPageOptions": { "alias": "rowsPerPageOptions"; "required": false; }; "metaKey": { "alias": "metaKey"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "presetSet": { "alias": "presetSet"; "required": false; }; "defaultColor": { "alias": "defaultColor"; "required": false; }; "mpp": { "alias": "mpp"; "required": false; }; "volumes": { "alias": "volumes"; "required": false; }; "labelDrafts": { "alias": "labelDrafts"; "required": false; }; }, { "selectionChange": "selectionChange"; "rowSelect": "rowSelect"; "labelEditStart": "labelEditStart"; "labelDraftChange": "labelDraftChange"; "labelEditStop": "labelEditStop"; "classPick": "classPick"; "deleteRow": "deleteRow"; "pageChange": "pageChange"; }, never, never, true, never>;
 }

package/lib/region-overlay/region-geometry.d.ts

@@ -70,16 +70,17 @@ export interface ContainsOptions {
  */
 export declare function regionContains(region: Pick<Region, 'bounds'>, x: number, y: number, opts?: ContainsOptions): boolean;
 /** Index of the topmost (last) region containing (x, y), or -1. */
-export declare function topmostRegionAt(regions: ReadonlyArray<Pick<Region, 'bounds'>>, x: number, y: number, opts?: ContainsOptions & {
-    skip?: (r: Pick<Region, 'bounds'>) => boolean;
+export declare function topmostRegionAt<R extends Pick<Region, 'bounds'>>(regions: ReadonlyArray<R>, x: number, y: number, opts?: ContainsOptions & {
+    skip?: (r: R) => boolean;
 }): number;
 /**
  * Indices of every region whose bounding box intersects the world box
  * [x0,y0]–[x1,y1] (rubber-band selection). `skipProfiles` leaves out
- * intensity-profile lines.
+ * intensity-profile lines, `skip` any other region.
  */
 export declare function regionsInRect(regions: ReadonlyArray<Region>, x0: number, y0: number, x1: number, y1: number, opts?: {
     skipProfiles?: boolean;
+    skip?: (r: Region) => boolean;
 }): number[];
 /** The handle offsets a bézier ring is drawn with; absent arrays fall back to the default. */
 export interface RingHandleOffsets {

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

@@ -0,0 +1,96 @@
+/**
+ * Draws a region source (see `region-source`) under the editable regions, at the level of detail
+ * the zoom calls for, from the tiles in view only — the way the spatial views draw cell outlines.
+ * Shared by the OpenSeadragon and napari overlays: both hand it their svg and their world → svg
+ * camera affine, as they do their {@link SvgRegionRenderer}.
+ *
+ * One `<path>` per colour (every ring of every feature of that colour, even-odd), in world
+ * coordinates inside one transformed group, so a camera move rewrites one attribute. The tiles in
+ * view are re-planned once the camera settles; while a finer tile loads its coarser parent is
+ * drawn instead, so zooming in sharpens the outlines rather than blanking them. Features taken
+ * into the working set (selected, edited) or deleted are not drawn: the region renderer draws the
+ * taken ones as ordinary regions.
+ *
+ * It also answers what is under a point, from the features drawn, for the overlays' selection.
+ */
+import type { Observable } from 'rxjs';
+import { RegionSourceView } from '../region-source/region-source';
+import { TileFeature } from '../region-source/region-tiles';
+import { Affine } from './svg-region-renderer';
+/** Wait this long after the last camera change before planning tiles (ms). */
+export declare const SOURCE_REPLAN_MS = 90;
+/** The view is padded by this fraction on each side, so a short pan finds its tiles loaded. */
+export declare const SOURCE_VIEW_MARGIN = 0.25;
+/** At most this many tiles in view. */
+export declare const SOURCE_MAX_TILES = 256;
+/** A rubber band takes at most this many source features into the working set. */
+export declare const SOURCE_MARQUEE_LIMIT = 2000;
+/** The svg size (local px), for the part of the world in view. */
+export type SvgSize = () => {
+    width: number;
+    height: number;
+};
+export declare class RegionSourceLayer {
+    private readonly svg;
+    private readonly size;
+    private readonly group;
+    private camera;
+    /** Class labels inside the features, in screen space over the outlines. */
+    private readonly labelLayer;
+    /** Class name → depth in the source's class hierarchy (parents draw under their children). */
+    private depthOf;
+    /** Class name → its parent class in the source's class hierarchy. */
+    private parentOf;
+    private view;
+    private visible;
+    private readonly sub;
+    /** Loaded tiles of the current source and plane, by id, least recently used first. */
+    private readonly tiles;
+    /** The tiles the view wants now. */
+    private wanted;
+    /** The features drawn, by id (each at the finest level loaded). */
+    private drawn;
+    private loading;
+    private replanTimer;
+    private drawFrame;
+    constructor(svg: SVGSVGElement, view$: Observable<RegionSourceView | null>, size?: SvgSize);
+    /** Follow the camera: rewrite the transform now, re-plan the tiles once it settles. */
+    setCamera(affine: Affine): void;
+    /** Show or hide the source with the regions. */
+    setVisible(visible: boolean): void;
+    /**
+     * The source feature under world point (x, y) — inside an area, or within `tolerancePx`
+     * screen pixels of a polyline — from the features drawn; the innermost of nested ones.
+     */
+    featureAt(x: number, y: number, tolerancePx?: number): TileFeature | null;
+    /** The drawn source features whose box meets the world box (the rubber band's rule). */
+    featuresInRect(x0: number, y0: number, x1: number, y1: number): TileFeature[];
+    destroy(): void;
+    private setView;
+    /** The layer is the svg's first child (under the regions) while it shows a source. */
+    private attach;
+    private applyCamera;
+    /** Screen px per world unit. */
+    private scale;
+    /** The world box in view, padded by the margin; null when the svg has no size yet. */
+    private viewRect;
+    /** Work out the tiles the view needs, draw what is loaded, and load the rest. */
+    private replan;
+    private keep;
+    private scheduleDraw;
+    /**
+     * Rebuild the paths from the wanted tiles that are loaded, a missing tile's nearest loaded
+     * ancestor standing in for it; each feature once, at the finest level loaded.
+     */
+    private draw;
+    /**
+     * The drawn features as paths: one per colour when outlined; filled, in paint order — parents
+     * (by the class hierarchy) and then larger features first, so what lies inside paints over
+     * them — one path per run of a colour.
+     */
+    private runs;
+    /** Class labels inside the drawn features (each part where it fits), when labels are on. */
+    private drawLabels;
+    /** The loaded tile for `key`, else its nearest loaded coarser ancestor. */
+    private loadedOrAncestor;
+}

package/lib/region-overlay/region-style.d.ts

@@ -0,0 +1,52 @@
+/**
+ * How regions are drawn, shared by the OpenSeadragon and napari overlays and the region-source
+ * layer, so a feature looks the same before and after it is taken into the regions.
+ *
+ * Two looks: **outlines** (the default — each region stroked in its colour, filled only while
+ * selected) and **filled**, an atlas's look (each region filled in its colour, with thin outlines,
+ * the selection in a highlight colour, labels centred inside each part).
+ */
+import { Region } from '../models/region';
+import type { Project, ScreenLayer } from './svg-region-renderer';
+/** The region look (see the module doc). */
+export interface RegionStyle {
+    /** Fill each region at this opacity; 0 draws outlines only. */
+    fillOpacity: number;
+    /** Outline colour of a filled region; null: its own colour. */
+    stroke: string | null;
+    /** Outline width of a filled region, screen px; null: 1. */
+    strokeWidth: number | null;
+    /** Fill colour of a selected filled region; null: {@link DEFAULT_HIGHLIGHT}. */
+    highlight: string | null;
+}
+export declare const DEFAULT_REGION_STYLE: RegionStyle;
+/** A selected region's fill in the filled look, unless the style names one (the Allen atlas's). */
+export declare const DEFAULT_HIGHLIGHT = "#a020f0";
+/** Whether `style` is the filled look. */
+export declare function isFilled(style: RegionStyle): boolean;
+/** The paint of one region shape. */
+export interface ShapePaint {
+    fill: string;
+    fillOpacity: number;
+    stroke: string;
+    strokeWidth: number;
+}
+/** The paint of a region of colour `color`, selected or not, in `style`. */
+export declare function shapePaint(color: string, selected: boolean, style?: RegionStyle): ShapePaint;
+/** Set `paint` on an SVG shape. */
+export declare function applyPaint(el: SVGElement, paint: ShapePaint): void;
+/** A point to label a part at, and the room around it (image px). */
+export interface LabelSpot {
+    x: number;
+    y: number;
+    room: number;
+}
+/** Where to label `region`: each part's pole of inaccessibility (a rectangle's centre). */
+export declare function regionLabelSpots(region: Region): LabelSpot[];
+/**
+ * A class label centred at `spot`, shown only while it fits: the room around the spot, on screen,
+ * at least half the text's width (and a few pixels). Re-checked on every camera move.
+ */
+export declare function placeInsideLabel(layer: ScreenLayer, text: string, spot: LabelSpot, color?: string): SVGTextElement;
+/** Whether a label `halfWidth` px wide fits around `spot` through `project`. */
+export declare function labelFits(project: Project, spot: LabelSpot, halfWidth: number): boolean;

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

@@ -0,0 +1,45 @@
+/**
+ * A {@link RegionSource} served over HTTP, by a server that tiles a region set as `region-tiles`
+ * does (the example tile server's `/regions/…` routes). Relative to the source's base URL:
+ *
+ *  - `GET  info`                       → {@link RegionSourceInfo}
+ *  - `GET  tile/{z}/{level}/{gx}/{gy}` → `{ features: WireTileFeature[] }`
+ *  - `POST features` `{ ids }`         → `{ features: SourceFeature[] }`
+ *  - `POST index` `{ z, ...query }`    → {@link RegionIndexPage}
+ *  - `POST classes` `{ z, exclude }`    → features per class on plane z
+ *  - `POST outlines` `{ classes, level, exclude }` → `{ slices: [{ z, rings }] }`
+ *  - `POST export` `{ exclude, extra }`→ a GeoJSON FeatureCollection
+ *
+ * Tile rings travel as flat `[x, y, x, y, …]` arrays, label points as flat `[x, y, room, …]`.
+ *
+ * Given the host's Angular `HttpClient` (as the visualizer passes it), every request goes through
+ * it, so the host's interceptors apply — its auth header above all — as for the image tiles and
+ * the spatial data. The library itself knows nothing of authentication.
+ */
+import type { HttpClient } from '@angular/common/http';
+import { RegionSource } from './region-source';
+import type { Bbox } from './region-tiles';
+/** A tile feature on the wire: rings as plain arrays. */
+export interface WireTileFeature {
+    id: string;
+    label: string | null;
+    color: string | null;
+    bbox: Bbox;
+    rings: number[][];
+    open?: boolean;
+    labels?: number[];
+}
+/** Options of {@link openHttpRegionSource}. */
+export interface HttpRegionSourceOptions {
+    /**
+     * The host's `HttpClient`: requests then go through it and its interceptors (the host's auth),
+     * not `fetch`, and `init` and `fetch` are not used.
+     */
+    http?: HttpClient;
+    /** Extra request options (credentials, headers) for every `fetch` request. */
+    init?: RequestInit;
+    /** The fetch to use (default the global one). */
+    fetch?: typeof fetch;
+}
+/** Open the region source at `baseUrl` (its `info` is fetched first). */
+export declare function openHttpRegionSource(baseUrl: string, options?: HttpRegionSourceOptions): Promise<RegionSource>;

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

@@ -0,0 +1,89 @@
+/**
+ * The region-source worker's protocol and the tables it holds, shared by the worker and the
+ * main-thread fallback (which runs the very same {@link RegionSourceTables} where no worker can
+ * start).
+ *
+ * Protocol: `{ id, op, ...args }` → `{ id, ok: true, result }` | `{ id, ok: false, error }`.
+ */
+import { ReconstructOptions, SliceOutlines } from '../geometry/reconstruct';
+import type { Mesh } from 'napari-js/geometry';
+import { ClassOutlines, RegionIndexPage, RegionIndexQuery, RegionSourceInfo, RegionTile } from './region-tiles';
+import type { SourceFeature } from './region-source';
+export type RegionSourceRequest = {
+    op: 'open';
+    text: string;
+    tileSize?: number;
+} | {
+    op: 'tile';
+    handle: number;
+    z: number;
+    level: number;
+    gx: number;
+    gy: number;
+} | {
+    op: 'features';
+    handle: number;
+    ids: readonly string[];
+} | {
+    op: 'index';
+    handle: number;
+    z: number;
+    query: RegionIndexQuery;
+} | {
+    op: 'classes';
+    handle: number;
+    z: number | null;
+    exclude?: readonly string[];
+} | {
+    op: 'outlines';
+    handle: number;
+    classes: readonly string[] | null;
+    level: number;
+    exclude?: readonly string[];
+} | {
+    op: 'mesh';
+    slices: readonly SliceOutlines[];
+    options?: ReconstructOptions;
+} | {
+    op: 'export';
+    handle: number;
+    exclude: readonly string[];
+    extra: readonly object[];
+} | {
+    op: 'close';
+    handle: number;
+};
+export interface RegionSourceResults {
+    open: {
+        handle: number;
+        info: RegionSourceInfo;
+    };
+    tile: RegionTile;
+    features: SourceFeature[];
+    index: RegionIndexPage;
+    classes: Record<string, number>;
+    outlines: ClassOutlines[];
+    mesh: Mesh;
+    export: string;
+    close: null;
+}
+export type RegionSourceMessage = RegionSourceRequest & {
+    id: number;
+};
+export type RegionSourceReply = {
+    id: number;
+    ok: true;
+    result: unknown;
+} | {
+    id: number;
+    ok: false;
+    error: string;
+};
+/** The open tables, by handle. */
+export declare class RegionSourceTables {
+    private readonly tables;
+    private nextHandle;
+    run<R extends RegionSourceRequest>(request: R): RegionSourceResults[R['op']];
+    private dispatch;
+    private table;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Factory for the region-source Web Worker, isolated in its own module so the `import.meta.url`
+ * reference — which the bundler needs in order to locate the worker — is never pulled into the
+ * ts-jest CommonJS compile of anything that uses it. Same arrangement as
+ * `workers/spatial-math-worker.ts`.
+ */
+export declare function createRegionSourceWorker(): Worker;