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

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

@@ -0,0 +1,77 @@
+import { Observable } from 'rxjs';
+import { Region } from '../models/region';
+import { IRegionEditorApi } from '../contracts/region-editor-api.contract';
+import { RegionIoPort } from '../contracts/ports/region-io.port';
+import * as i0 from "@angular/core";
+/** One slice-file's serialized regions (folder stack, jit-ui#93). */
+export interface SliceGeoJson {
+    z: number;
+    geoJsonStr: string;
+}
+/**
+ * Region file I/O for the Region Editor: default file names, GeoJSON download
+ * (export), save to the host through {@link RegionIoPort} (with a debounced
+ * "file exists" check), per-slice saves for folder stacks, and reading an
+ * imported file. Provided by the editor; it holds no state — the editor owns
+ * the dialogs, the toasts and the running jobs.
+ */
+export declare class RegionPersistenceService {
+    private readonly api;
+    private readonly io;
+    constructor(api: IRegionEditorApi, io: RegionIoPort);
+    /** The selected image's file name, if any. */
+    selectedFileName(): string | undefined;
+    /** `<image-stem>.geojson` for a server save; undefined with no image selected. */
+    defaultSaveName(): string | undefined;
+    /** `<image-stem>.geojson` (or `rois.geojson`) for a download. */
+    defaultExportName(): string;
+    /** `<image-stem>_mask.png` (or `regions_mask.png`) for a mask download. */
+    defaultMaskName(): string;
+    /** True when a save writes one geojson per slice-file (folder stack, jit-ui#93). */
+    savesPerSlice(): boolean;
+    /**
+     * Regions to serialize on save/export. For a single-file z-stack the store
+     * keeps only the current slice live, so take EVERY slice's annotations (each
+     * tagged with its zero-based Region.z) for one combined z-indexed geojson
+     * (jit-ui#93); otherwise `live` (single plane, or a folder stack whose slices
+     * save to their own files).
+     */
+    regionsForSave(live: Region[]): Region[];
+    /**
+     * Whether each file name in `names` already exists on the host, debounced
+     * 400 ms; a newer name supersedes an in-flight check. A failed check reads as
+     * "does not exist" and later checks keep working.
+     */
+    fileExists(names: Observable<string>): Observable<boolean>;
+    /**
+     * `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
+     * serialize); unsubscribing before then cancels the save entirely, and after
+     * it cancels the upload. A serialize failure is an error, like an upload one.
+     */
+    save(regions: () => Region[], filename: string): Observable<void>;
+    /**
+     * 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, and so are slices
+     * whose region source lost features; a slice with a region source keeps the features still
+     * in it.
+     */
+    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
+     *  `onText`. No-op when no file was chosen. */
+    readChosenFile(event: Event, onText: (text: string) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionPersistenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegionPersistenceService>;
+}

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

@@ -0,0 +1,89 @@
+import { EventEmitter, OnChanges } from '@angular/core';
+import { Region } from '../../models/region';
+import { PresetSet } from '../../models/class-preset';
+import { PixelSize } from '../region-metrics';
+import * as i0 from "@angular/core";
+/** A page change from the paginator. */
+export interface RegionPage {
+    first: number;
+    rows: number;
+}
+/**
+ * The Region Editor's regions table and paginator: one page of rows with a
+ * class dropdown (or an inline label editor), the area, and a delete button.
+ * Presentational and OnPush: the editor owns the rows, the selection, the
+ * paging and the label drafts, and applies every edit through its one
+ * copy-on-write commit path — the table never changes a {@link Region}.
+ */
+export declare class RegionTableComponent implements OnChanges {
+    /** The rows on the current page. */
+    page: Region[];
+    /** Total number of rows (all pages). */
+    total: number;
+    /** Index of the page's first row across all pages. */
+    first: number;
+    /** Rows per page. */
+    rows: number;
+    /** The paginator's rows-per-page choices. */
+    rowsPerPageOptions: number[];
+    /** Ctrl/Cmd-click toggles a row (PrimeNG metaKeySelection). */
+    metaKey: boolean;
+    /** The selected rows. */
+    selection: Region[];
+    /** The table's selection changed (any row click). */
+    selectionChange: EventEmitter<Region[]>;
+    /** A row was selected or unselected (after {@link selectionChange}). */
+    rowSelect: EventEmitter<void>;
+    /** Classes for the per-row dropdown, and their colours. */
+    presetSet: PresetSet;
+    /** Swatch colour of an unlabelled row. */
+    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. */
+    labelEditStart: EventEmitter<Region>;
+    /** The inline label editor's text changed. */
+    labelDraftChange: EventEmitter<{
+        region: Region;
+        value: string;
+    }>;
+    /** The inline label editor closed: Enter commits, Escape / close cancels. */
+    labelEditStop: EventEmitter<{
+        region: Region;
+        commit: boolean;
+    }>;
+    /** A class was picked in a row's dropdown. */
+    classPick: EventEmitter<{
+        region: Region;
+        name: string;
+    }>;
+    /** A row's trash button: the row's index across all pages. */
+    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 (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;
+        measure: string;
+    }>;
+    ngOnChanges(): void;
+    private measure;
+    private classColor;
+    private area;
+    protected startEdit(region: Region, event: Event): void;
+    protected stopEdit(region: Region, commit: boolean, event: Event): void;
+    protected onPage(event: {
+        first?: number;
+        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; }; "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-editor/save-mask-dialog/save-mask-dialog.component.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from '@angular/core';
+import { MaskMode } from '../mask-export.service';
+import * as i0 from "@angular/core";
+/**
+ * The Region Editor's "Save mask" dialog: filename + mask type while idle, a
+ * progress bar (rasterize, then encode) with a Cancel button while the export
+ * runs. Presentational — the editor owns the state and the export
+ * ({@link MaskExportService}); the dialog only reports edits and clicks.
+ */
+export declare class SaveMaskDialogComponent {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** The PNG filename. */
+    filename: string;
+    /** The filename was edited; two-way with {@link filename}. */
+    filenameChange: EventEmitter<string>;
+    /** The mask type: binary, or one label value per class. */
+    mode: MaskMode;
+    /** The mask type was changed; two-way with {@link mode}. */
+    modeChange: EventEmitter<MaskMode>;
+    /** True while the export runs (the form is replaced by progress). */
+    busy: boolean;
+    /** 0–100 rasterization progress. */
+    progress: number;
+    /** True once rasterizing is done and the PNG is being encoded. */
+    encoding: boolean;
+    /** Download clicked with a non-blank filename. */
+    confirm: EventEmitter<void>;
+    /** Cancel clicked while the export runs. */
+    cancelExport: EventEmitter<void>;
+    protected close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SaveMaskDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SaveMaskDialogComponent, "region-save-mask-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "filename": { "alias": "filename"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "busy": { "alias": "busy"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "encoding": { "alias": "encoding"; "required": false; }; }, { "visibleChange": "visibleChange"; "filenameChange": "filenameChange"; "modeChange": "modeChange"; "confirm": "confirm"; "cancelExport": "cancelExport"; }, never, never, true, never>;
+}

package/lib/region-editor/save-regions-dialog/save-regions-dialog.component.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A GeoJSON filename dialog, used by the Region Editor for both "Save Regions
+ * As" (server save: overwrite warning, progress + Cancel while busy) and
+ * "Export Regions" (download). Presentational — the editor owns the state and
+ * the I/O ({@link RegionPersistenceService}).
+ */
+export declare class SaveRegionsDialogComponent {
+    /** The dialog title. */
+    header: string;
+    /** The confirm button's label. */
+    confirmLabel: string;
+    /** The confirm button's PrimeIcons class. */
+    confirmIcon: string;
+    /** id of the filename input (unique per dialog instance). */
+    inputId: string;
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** The GeoJSON filename. */
+    filename: string;
+    /** The filename was edited; two-way with {@link filename}. */
+    filenameChange: EventEmitter<string>;
+    /** Shows the "will be overwritten" warning. */
+    fileExists: boolean;
+    /** True while the save runs (the form is replaced by progress). */
+    busy: boolean;
+    /** Save/Export clicked with a non-blank filename. */
+    confirm: EventEmitter<void>;
+    /** Cancel clicked while the save runs. */
+    cancelSave: EventEmitter<void>;
+    protected close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SaveRegionsDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SaveRegionsDialogComponent, "region-save-regions-dialog", never, { "header": { "alias": "header"; "required": false; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; }; "confirmIcon": { "alias": "confirmIcon"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "filename": { "alias": "filename"; "required": false; }; "fileExists": { "alias": "fileExists"; "required": false; }; "busy": { "alias": "busy"; "required": false; }; }, { "visibleChange": "visibleChange"; "filenameChange": "filenameChange"; "confirm": "confirm"; "cancelSave": "cancelSave"; }, never, never, true, never>;
+}

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

@@ -1,11 +1,10 @@
 import { Region } from './models/region';
-import { WandService } from './toolbar/wand/wand.service';
 import * as i0 from "@angular/core";
 /**
  * Pure (DOM-free) region set-operations — merge / inverse / ungroup (jit-ui#85).
  *
  * Raster-based, reusing the wand/brush mask pipeline
- * ({@link WandService.rasterizePolygon} → {@link WandService.maskToPolygons}),
+ * ({@link rasterizePolygon} → {@link maskToPolygons}, the pure `geometry/` modules),
  * so "select + merge" yields the same geometry as brushing regions together:
  * one engine, one set of behaviours, holes + multi-part results for free.
  *
@@ -15,7 +14,6 @@ import * as i0 from "@angular/core";
  * image pixels throughout.
  */
 export declare class RegionOpsService {
-    private wand;
     /**
      * Largest raster (in pixels) a region set-op will allocate on the main thread.
      * Selections whose clipped bbox exceeds this are rasterized at a proportional
@@ -25,7 +23,6 @@ export declare class RegionOpsService {
      * large-extent selections (small selections keep full resolution).
      */
     private static readonly MAX_OP_PIXELS;
-    constructor(wand: WandService);
     /**
      * Geometric union of `regions` into a single region: a {@link Polygon} when
      * the union is one connected piece, a {@link MultiPolygon} when it stays
@@ -51,8 +48,6 @@ export declare class RegionOpsService {
      * no full-image buffer is ever allocated.
      */
     inverse(regions: Region[], imageWidth: number, imageHeight: number): Region | null;
-    /** A closed straight-edged Polygon from parallel coord arrays. */
-    private ringPolygon;
     /**
      * Split a region into its disjoint parts — one region per {@link MultiPolygon}
      * part. A single connected {@link Polygon}/{@link Rectangle} has nothing to
@@ -86,7 +81,6 @@ export declare class RegionOpsService {
      *  inheriting colour/label from `proto`. Null when there are no parts. */
     private regionFromParts;
     private makeRegion;
-    private clonePolygon;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionOpsService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<RegionOpsService>;
 }

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

@@ -0,0 +1,158 @@
+/**
+ * Region-overlay geometry shared by the OpenSeadragon and napari overlays
+ * (review NAPARI-BOUNDARY-13, OSD-PLOTLY-16).
+ *
+ * Both overlays used to carry their own copy of this code, and the copies had
+ * drifted: napari's hit test ignored holes, multi-part regions and open
+ * polylines, its bézier path drew straight edges without stored handles, and it
+ * rendered nothing for a MultiPolygon. Everything here is pure — no DOM, no
+ * viewer — so the overlays are left with gestures and DOM.
+ *
+ * Coordinates: regions are in WORLD (image-pixel) space. Functions that need a
+ * screen-space tolerance (an open polyline's hit width, a handle's grab
+ * radius) take a {@link ToScreen} projection and measure in its pixels, so they
+ * stay usable at any zoom. Point-in-ring and ring bounds come from
+ * `geometry/ring`.
+ */
+import { Polygon, Region } from '../models/region';
+import { AnchorHandle } from '../models/bezier';
+/** World → screen projection, e.g. image → element pixels. */
+export type ToScreen = (x: number, y: number) => readonly [number, number];
+/** The identity projection: path data stays in world coordinates. */
+export declare const WORLD: ToScreen;
+/** An axis-aligned box (inclusive corners). */
+export interface BBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** Screen-px distance from an open polyline within which a point is on it. */
+export declare const OPEN_PATH_TOL_PX = 6;
+type AnyBounds = Region['bounds'] | Record<string, unknown>;
+/**
+ * Discriminate a region's bounds. Class instances first; plain objects with the
+ * right fields too, so a region that skipped the store's hydration (JSON from a
+ * host) still draws and hit-tests (jit-ui#124).
+ */
+export declare function boundsKind(b: AnyBounds | null | undefined): 'rect' | 'poly' | 'multi' | null;
+/** A polygon's ring as parallel arrays: the exterior for `ring` -1, else hole `ring`. */
+export declare function ringOf(p: Polygon, ring: number): {
+    xs: number[];
+    ys: number[];
+};
+/**
+ * A polygon ring's bézier handles (absolute, world space): the stored offsets
+ * when present, else the Catmull-Rom default the curve is drawn with. Holes are
+ * always closed.
+ */
+export declare function ringHandles(p: Polygon, ring: number): AnchorHandle[];
+/**
+ * A region's axis-aligned bounding box in world coordinates (every part of a
+ * multi-polygon), or null for empty geometry. Loops rather than
+ * `Math.min(...spread)`, which throws on a large imported annotation.
+ */
+export declare function regionBBox(region: Pick<Region, 'bounds'>): BBox | null;
+/** Shortest distance from (px,py) to the segment (ax,ay)–(bx,by), in the units given. */
+export declare function segmentDistance(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+/** Options for {@link regionContains}. */
+export interface ContainsOptions {
+    /** Projection the open-polyline tolerance is measured in. Default: world units. */
+    toScreen?: ToScreen;
+    /** Open-polyline hit width, in `toScreen` pixels. Default {@link OPEN_PATH_TOL_PX}. */
+    tolPx?: number;
+}
+/**
+ * Whether world point (x, y) lands on `region`: a rectangle by its (inclusive)
+ * box; a closed polygon by its exterior minus its holes; a multi-polygon by any
+ * part (minus that part's holes); an open polyline — which has no interior —
+ * within `tolPx` screen pixels of its line.
+ */
+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<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, `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 {
+    in?: number[][];
+    out?: number[][];
+}
+/**
+ * SVG path `d` for one ring or polyline, projected through `toScreen`.
+ * Straight edges without `handles`; with `handles`, cubic segments through the
+ * stored offsets, or the Catmull-Rom default when they are missing or do not
+ * match the ring (via `resolveHandles`). Closed rings end in `Z`. '' for fewer
+ * than two vertices.
+ */
+export declare function ringPathD(xs: number[], ys: number[], closed: boolean, toScreen: ToScreen, handles?: RingHandleOffsets): string;
+/**
+ * SVG path `d` for a whole region: a rectangle's four corners; a polygon's
+ * exterior (curved for a bézier region) followed by one subpath per hole
+ * (curved too for a bézier donut); a multi-polygon's parts with their holes.
+ * Holes need `fill-rule: evenodd` (see {@link regionHasHoles}).
+ */
+export declare function regionPathD(region: Pick<Region, 'bounds'>, toScreen?: ToScreen): string;
+/** True when the region draws as several subpaths that need `fill-rule: evenodd`. */
+export declare function regionHasHoles(region: Pick<Region, 'bounds'>): boolean;
+/** What a pointer grabbed on the selected region (see {@link hitHandle}). */
+export type HandleHit = 
+/** A rectangle corner; `anchor` is the opposite (fixed) corner for a resize. */
+{
+    kind: 'corner';
+    index: number;
+    anchor: [number, number];
+}
+/** A polygon vertex: `ring` -1 for the exterior, else the hole index. */
+ | {
+    kind: 'vertex';
+    ring: number;
+    index: number;
+}
+/** A bézier control point of vertex `index` on `ring`. */
+ | {
+    kind: 'bezier';
+    ring: number;
+    index: number;
+    side: 'in' | 'out';
+};
+/**
+ * The handle of `region` under screen point (sx, sy) within `radius` screen
+ * pixels, or null. Rectangles have four corners. Polygons: every bézier
+ * control point first (exterior, then each hole; they sit off the anchors, so
+ * they must win), then the vertices (exterior, then each hole). Pass
+ * `{ bezier: false }` to test vertices only.
+ */
+export declare function hitHandle(region: Pick<Region, 'bounds'>, sx: number, sy: number, toScreen: ToScreen, radius: number, opts?: {
+    bezier?: boolean;
+}): HandleHit | null;
+/**
+ * The polygon edge nearest screen point (sx, sy), across the exterior and every
+ * hole: its ring (-1 = exterior), the index of its start vertex, and the
+ * distance in screen pixels. Null when the region is not a polygon.
+ */
+export declare function nearestEdge(region: Pick<Region, 'bounds'>, sx: number, sy: number, toScreen: ToScreen): {
+    ring: number;
+    segIndex: number;
+    dist: number;
+} | null;
+/**
+ * The polygon vertex nearest world point (x, y), across the exterior and every
+ * hole, with its distance in world units. Null when the region is not a
+ * polygon or has no vertices.
+ */
+export declare function nearestVertex(region: Pick<Region, 'bounds'>, x: number, y: number): {
+    ring: number;
+    index: number;
+    dist: number;
+} | null;
+export {};

package/lib/region-overlay/region-hit-test.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Screen-space hit testing for a selected rectangle's move/resize zones, and the
+ * resize those zones drive. Pure; shared by the SVG region overlays. (Vertex,
+ * bezier-handle and edge hits on polygons live in `region-geometry.ts`:
+ * `hitHandle` and `nearestEdge`.)
+ */
+/** Move/resize zones on the selected rectangle. */
+export type EditZone = 'move' | 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+/** The cursor that advertises each zone. */
+export declare const ZONE_CURSOR: Readonly<Record<EditZone, string>>;
+/** Screen-pixel tolerance for grabbing an edge, corner or vertex handle. */
+export declare const EDIT_TOL_PX = 8;
+/** A screen-space box: left, top, right, bottom. */
+export interface ScreenBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * Classify a screen point against a screen-space rectangle: a corner, an edge
+ * (within `tolPx`), the body, or null when outside (beyond the tolerance).
+ */
+export declare function rectZone(px: number, py: number, box: ScreenBox, tolPx?: number): EditZone | null;
+/** An image-space rectangle. */
+export interface RectBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The rectangle `orig` moved or resized through `zone` by the total drag
+ * (`dx`, `dy`), normalised (a drag past the opposite edge flips it) and rounded
+ * to whole pixels. Absolute from the gesture-start box, so applying it on every
+ * frame is idempotent.
+ */
+export declare function resizeRect(orig: RectBox, zone: EditZone, dx: number, dy: number): RectBox;

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;