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

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

@@ -1,112 +1,162 @@
 import { OnDestroy, OnInit } from '@angular/core';
-import { OverlayPanel } from 'primeng/overlaypanel';
 import { Region } from '../models/region';
 import { PresetSet, ClassPreset } from '../models/class-preset';
 import { ConfirmationService, MessageService } from 'primeng/api';
 import { IRegionEditorApi } from '../contracts/region-editor-api.contract';
-import { RegionIoPort } from '../contracts/ports/region-io.port';
+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";
 export declare class RegionEditorComponent implements OnInit, OnDestroy {
     private regionApi;
-    messageService: MessageService;
+    private messageService;
     private confirmationService;
-    private regionIo;
-    protected readonly Array: ArrayConstructor;
-    overlayPanel: OverlayPanel;
-    regions: Region[];
-    regionsCopy: Region[];
-    selectedRegions: Region[];
-    showShapeLabel: boolean;
-    shapeColor: string;
-    fillColor: string;
-    displayHelpDialog: boolean;
-    showColorDialog: boolean;
+    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;
+    protected shapeColor: string;
+    protected fillColor: string;
+    protected displayHelpDialog: boolean;
+    protected showColorDialog: boolean;
     /** One colour editor per unique class among the selected regions, shown in the
      *  "edit colour of selected regions" dialog. Unclassified regions (no label)
      *  are grouped under a single entry with an empty `label`. */
-    classColorEdits: {
-        label: string;
-        color: string;
-    }[];
-    labelColors: Map<string, string>;
-    selectedLabelColor: string;
+    protected classColorEdits: ClassColorEdit[];
     /** "Edit class on selected rows" popup: chosen existing class, and a new-class name. */
-    bulkClass: string;
-    newBulkClass: string;
+    protected bulkClass: string;
+    protected newBulkClass: string;
     /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */
-    presetSet: PresetSet;
-    /** Class applied to newly drawn/added regions and to bulk chip-clicks. */
-    activeClass: string | null;
-    showManageDialog: boolean;
+    protected presetSet: PresetSet;
+    /** The class last picked in the panel; a chip-click applies it to the selected rows. */
+    protected activeClass: string | null;
+    protected showManageDialog: boolean;
     /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */
-    presetDraft: PresetSet | null;
+    protected presetDraft: PresetSet | null;
     /** class name (match-mode keyed) → number of regions currently using it. */
-    classCounts: Map<string, number>;
+    protected classCounts: Map<string, number>;
     /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */
-    readonly defaultClassName = "Region";
+    protected readonly defaultClassName = "Region";
     /** Classes as shown in the panel: sorted by region count (desc), then name. */
-    displayClasses: ClassPreset[];
-    readonly matchModeOptions: {
-        label: string;
-        value: string;
-    }[];
-    paginatorFirst: number;
-    paginatorRows: number;
-    readonly rowsPerPageOptions: number[];
-    /** Regions whose Class cell is currently in edit mode.
-     *  Using object identity as the key avoids needing a unique id field. */
-    editingLabelRegions: Set<any>;
-    showSaveAsDialog: boolean;
-    saveAsFilename: string;
-    saveAsFileExists: boolean;
+    protected displayClasses: ClassPreset[];
+    protected paginatorFirst: number;
+    protected paginatorRows: number;
+    protected readonly rowsPerPageOptions: number[];
+    /** Regions whose Class cell is currently in edit mode → the label being typed.
+     *  The draft is committed on Enter and discarded on Escape/✕, so typing never
+     *  writes into the store's region (RT-18). Keyed by object identity, which
+     *  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
      *  progress bar and Cancel button (parity with the Save-mask dialog). */
-    saveAsBusy: boolean;
-    private _saveAsCheck$;
+    protected saveAsBusy: boolean;
+    /** The running GeoJSON save; unsubscribing cancels it (Cancel / destroy). */
     private _saveAsSub?;
-    /** Handle for the deferred-serialize timer so Cancel/destroy can abort it
-     *  before it fires (otherwise the upload would still start). */
-    private _saveAsTimer?;
-    showExportDialog: boolean;
-    exportFilename: string;
-    showSaveMaskDialog: boolean;
-    saveMaskFilename: string;
+    /** Save-as file names to check for an existing file (debounced). */
+    private readonly saveAsCheck$;
+    protected showExportDialog: boolean;
+    protected exportFilename: string;
+    protected showSaveMaskDialog: boolean;
+    protected saveMaskFilename: string;
     /** Mask type chosen in the Save-mask dialog: a binary foreground/background
      *  mask, or a multi-class mask with a distinct id per region. */
-    maskMode: 'binary' | 'multiclass';
+    protected maskMode: MaskMode;
     /** True while the mask worker is rasterizing/encoding — drives the progress
      *  bar and the Cancel button in the dialog. */
-    maskBusy: boolean;
+    protected maskBusy: boolean;
     /** 0–100 rasterization progress; switches to indeterminate during encoding. */
-    maskProgress: number;
-    maskEncoding: boolean;
-    private maskWorker?;
-    private pendingMaskFilename;
+    protected maskProgress: number;
+    protected maskEncoding: boolean;
+    /** The running mask export; unsubscribing cancels it (terminates its worker). */
+    private maskJob?;
     /**
      * PrimeNG p-table multi-selection mode toggle. When true, single-click
      * selects one row (replacing prior); meta/ctrl-click toggles a row in/out
      * of the selection. When false, every click toggles. Default true to
      * match the most common spreadsheet-like UX.
      */
-    metaKey: boolean;
+    protected metaKey: boolean;
     private _updatingFromEditor;
     private _suppressSelectionSyncToPlot;
-    private _regionSub;
-    private _selectedIdxSub;
-    private _metaSub;
-    private _presetSub;
+    private readonly destroyRef;
+    private readonly cdr;
+    private readonly zone;
+    /** Re-render this OnPush view, re-entering the zone when the change came from outside it. */
+    private changed;
     /** Physical pixel size (µm/pixel) of the active image, for region areas in
-     *  µm². Undefined when the format reports no physical size. */
-    private mppX?;
-    private mppY?;
-    constructor(regionApi: IRegionEditorApi, messageService: MessageService, confirmationService: ConfirmationService, regionIo: RegionIoPort);
-    /**
-     * Deep copy of regions for dirty-tracking (`regionsCopy`). Returns plain-object
-     * clones — only structural equality matters here, not prototypes.
-     * TODO: replace with `structuredClone` once verified.
-     */
-    private deepClone;
+     *  µm²; empty when the format reports no physical size. */
+    protected mpp: PixelSize;
+    constructor(regionApi: IRegionEditorApi, messageService: MessageService, confirmationService: ConfirmationService, persistence: RegionPersistenceService, maskExport: MaskExportService);
     ngOnInit(): void;
+    /** Cancels a running GeoJSON save (aborts its upload) and mask export (terminates
+     *  its worker); the API subscriptions end through `takeUntilDestroyed`. */
     ngOnDestroy(): void;
     /**
      * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating
@@ -114,96 +164,137 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
      * the package maps them to its internal index space (which includes the
      * intensity-profile lines the editor never sees).
      */
-    onSelectionChanged(): void;
+    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;
     /**
-     * Apply classification colours and refresh the label→colour map for regions
-     * coming from the visualizer. The visualizer hands back neutral `Region`
-     * objects with bounds, colour and label already populated, so the editor no
-     * longer parses any backend-specific shape format — it only fills in a
-     * fallback colour and rebuilds its local label→colour lookup.
+     * 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 applyRegionColors;
+    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;
     /**
-     * Push edits from the editor to the diagram in live-edit mode (no save /
-     * cancel buttons). The `_updatingFromEditor` guard is still used so the
-     * resulting regionUpdateEvent doesn't bounce back as an external change.
+     * 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.
      */
-    private setRegionsFromEditor;
-    /** Set one region's outline colour from the per-row picker and commit live.
-     *  Remembers it as the label's colour so same-class regions added later match
-     *  (jit-ui#85 — the Region Editor's per-region Color column). */
-    changeRegionColor(region: Region, color: string): void;
-    addRectangle(): void;
+    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;
     /**
-     * Update the label of the region on enter key pressed (when editing a label cell in the table)
-     * @param region
-     * @param setRegion
+     * 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.
      */
-    labelRegionUpdate(region: Region, setRegion?: boolean): void;
-    xRectUpdate(region: Region, event: any): void;
-    yRectUpdate(region: Region, event: any): void;
-    widthRectUpdate(region: Region, event: any): void;
-    heightRectUpdate(region: Region, event: any): void;
-    onPageChange(event: {
-        first?: number;
-        rows?: number;
-    }): void;
-    /** Select every region in the table (and highlight them on the diagram). */
-    selectAllRegions(): void;
-    deleteSelectedRegions(): void;
-    clearAllRegions(): void;
-    addPolygon(): void;
-    deleteRegion(shapeIdx: number): void;
-    private clampPaginatorFirst;
-    changeShowShapeLabel(showLabel: boolean): void;
-    isEditingLabel(region: any): boolean;
-    startEditLabel(region: any, event?: Event): void;
-    stopEditLabel(region: any, commit: boolean, event?: Event): void;
-    isRectangle(region: Region): boolean;
+    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
+     * its classification colour (or the default shape colour) — as a copy: the
+     * store's instances are shared with its undo history and must not be changed
+     * in place (RT-1).
+     */
+    private applyRegionColors;
     /**
-     * Region area for display: in µm² (or mm²) when the image reports a physical
-     * pixel size, otherwise in px². Empty string for degenerate regions.
+     * The editor's one write path (RT-1): make `next` the table's rows and commit
+     * them to the store — live, as one undoable step (isRegionSaveOn=true; the
+     * router keeps the intensity-profile lines). Rows are the store's instances,
+     * so an edit passes copies ({@link patchRegions}), never changed rows. The
+     * resulting region-update event is ignored (`_updatingFromEditor`), so the
+     * class list and counts are refreshed here (a typed class is added; jit-ui#70).
      */
-    regionArea(region: Region): string;
+    private commit;
     /**
-     * Choose the physical pixel size (µm/pixel) for area display from the image
-     * meta. The calibration may sit on any channel entry — not necessarily [0] —
-     * so pick the first entry with a positive mppX (mirrors
-     * PlotlyService.currentMpp). Falls back to square pixels (mppY = mppX) when
-     * only one axis is reported, so a scaled image shows µm²/mm² rather than px².
+     * Copy-on-write edit (review RT-1). The editor's rows are the region store's
+     * live instances, and the store takes its undo snapshot only when the edit is
+     * committed — so an edit must replace a region with a patched copy (and any
+     * bounds it changes with new bounds), never mutate the instance the store
+     * holds. Returns the copies by original; the selection and an open label edit
+     * follow them.
      */
-    private pickMpp;
-    /** Pixel area: width·height for rectangles, shoelace formula for polygons.
-     *  Interior rings (holes) are subtracted, so a donut reports the annulus area,
-     *  not the filled exterior (jit-ui#85). */
-    private areaInPixels;
-    /** Polygon area: exterior shoelace minus each interior ring (hole). */
-    private polygonArea;
-    /** Absolute shoelace area of a single ring. */
-    private ringArea;
-    private fmtArea;
+    private patchRegions;
+    /** Set one region's outline colour (an explicit override) and commit live. */
+    protected changeRegionColor(region: Region, color: string): void;
     /**
-     * This method rounds all the rectangle regions lengths to multiple of 512
+     * After a label edit on `region`: give every labelled row without a colour its
+     * class colour (preset or fallback, as the store will), and commit when
+     * `commit` is set.
      */
-    roundRectangleLengths(): void;
+    protected labelRegionUpdate(region: Region, commit?: boolean): void;
+    /** Labelled rows without a colour get their class colour (copies). */
+    private fillClassColors;
+    /** 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), 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;
+    protected isEditingLabel(region: Region): boolean;
+    protected startEditLabel(region: Region, event?: Event): void;
+    /** The label typed so far for a row in edit mode (no re-render needed). */
+    protected setLabelDraft(region: Region, value: string): void;
+    protected stopEditLabel(region: Region, commit: boolean, event?: Event): void;
+    /** Region area for display (µm²/mm² when the image is scaled, else px²);
+     *  empty for a degenerate region. See `region-metrics`. */
+    protected regionArea(region: Region): string;
     /**
-     * Stop key arrow event propagation
-     * @param event
+     * This method rounds all the rectangle regions lengths to multiple of 512
      */
-    disableArrowKeys(event: any): void;
-    changeShapeColor(event: any): void;
-    showHelp(): void;
+    protected roundRectangleLengths(): void;
+    protected showHelp(): void;
     /** Open the colour dialog for the currently-selected region(s), building one
      *  colour picker per unique class in the selection. Each picker is seeded with
-     *  the class's current colour (the label→colour map, falling back to the first
-     *  selected region of that class). */
-    openColorDialog(): void;
-    /** Apply each class's chosen colour to the selected regions of that class and
-     *  commit live. Remembers the colour per class so same-class regions added
-     *  later match. */
-    applyColorToSelected(): void;
+     *  the first selected region of that class's colour (else the class colour). */
+    protected openColorDialog(): void;
+    /** Apply each class's chosen colour to the selected regions of that class (an
+     *  explicit override) and commit live. */
+    protected applyColorToSelected(edits?: ClassColorEdit[]): void;
     /** Resolve the display colour for a class name (preset colour or deterministic fallback). */
-    colorForName(name?: string): string;
+    protected colorForName(name?: string): string;
     /**
      * Ensure every class label present in the loaded regions exists in the preset
      * list, auto-adding any that are missing (using the region's already-resolved
@@ -213,93 +304,85 @@ 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;
-    /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
-    trackByClassName: (_: number, c: ClassPreset) => string;
     /** Number of regions currently using a class (keyed by the active match mode). */
-    classCount(name: string): number;
+    protected classCount(name: string): number;
     /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */
-    setClassColor(name: string, color: string): void;
-    /** Tooltip for a class's delete button in the panel. */
-    deleteClassTooltip(name: string): string;
+    protected setClassColor(name: string, color: string): void;
     /** Remove a class. Any regions still using it fall back to the default
      *  "Region" class, so they aren't orphaned (and the class isn't immediately
      *  re-added from its regions by syncClassesFromRegions). */
-    deleteClass(name: string): void;
+    protected deleteClass(name: string): void;
     /** Regions labelled with any of `removedNames` revert to the default
      *  {@link defaultClassName} ("Region"): its class colour, override cleared.
      *  Skips the default itself so deleting "Region" can't self-reassign. (jit-ui#70) */
     private reassignRegionsToDefaultClass;
     /** Stamp a class (and its preset/fallback colour) onto one region from the Class
      *  dropdown; choosing a class opts the region back into the preset colour. */
-    applyPresetToRegion(region: Region, className: string): void;
+    protected applyPresetToRegion(region: Region, className: string): void;
     /** Make a class active (used for new regions) and, if rows are selected, apply
      *  it to them in one commit. */
-    selectActiveClass(name: string): void;
+    protected selectActiveClass(name: string): void;
     /** Apply a class (label + preset/fallback colour) to the current selection and commit. */
     private applyClassToSelected;
     /** "Edit class on selected rows" popup — apply the chosen existing class. */
-    applyBulkClass(): void;
+    protected applyBulkClass(): void;
     /** "Edit class on selected rows" popup — add a new class and set it on the selection. */
-    addAndApplyBulkClass(): void;
-    openManageDialog(): void;
+    protected addAndApplyBulkClass(): void;
+    protected openManageDialog(): void;
     private clonePresetSet;
-    addPresetClass(): void;
-    removePresetClass(i: number): void;
-    addFallbackColor(): void;
-    removeFallbackColor(i: number): void;
     /** Commit the draft: drop blank/duplicate names, persist, and recolour
      *  non-overridden regions with the updated presets. */
-    applyManageDialog(close: boolean): void;
-    resetPresetsToDefaults(): void;
-    exportPresets(): void;
-    importPresets(event: Event): void;
-    importRois(event: Event): void;
+    protected applyManageDialog(close: boolean): void;
+    protected resetPresetsToDefaults(): void;
+    protected exportPresets(): void;
+    protected importPresets(event: Event): void;
+    /** Validate and apply an imported annotation-classes JSON file. */
+    private applyImportedPresets;
+    protected importRois(event: Event): void;
     /**
-     * Regions to serialize on save/export. For a single-file z-stack the store
-     * keeps only the current slice live, so pull EVERY slice's annotations (each
-     * tagged with its zero-based Region.z) to write one combined z-indexed
-     * geojson (jit-ui#93). Otherwise (single-plane image, or a folder stack whose
-     * slices save to their own per-slice files) the current set. (jit-ui#93)
+     * 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;
-    exportRois(): void;
-    confirmExport(): void;
+    protected exportRois(): void;
+    protected confirmExport(): void;
     /** Open the "Save mask" dialog, seeded with `<image-stem>_mask.png`. */
-    openSaveMaskDialog(): void;
+    protected openSaveMaskDialog(): void;
     /**
      * Rasterize the regions to the chosen mask type and download as a PNG. The
-     * heavy work (full-res rasterize + PNG encode) runs in a Web Worker so the UI
-     * never freezes on large/whole-slide images and the job can be cancelled
-     * (jit-ui#95). The dialog stays open showing a progress bar until done.
+     * heavy work runs in a Web Worker ({@link MaskExportService}) so the UI never
+     * freezes on whole-slide images and the job can be cancelled (jit-ui#95);
+     * the dialog stays open with a progress bar until done.
      */
-    confirmSaveMask(): void;
-    /** Cancel an in-progress mask export: terminate the worker and reset state. */
-    cancelSaveMask(): void;
-    /** Worker factory — async so the worker module (and its `import.meta.url`,
-     *  which the CommonJS test compile rejects) is loaded via a dynamic import,
-     *  exactly like the segmentation worker. Overridable in tests. */
-    protected createMaskWorker(): Promise<Worker>;
+    protected confirmSaveMask(): void;
+    /** Cancel an in-progress mask export (terminates its worker) and reset state. */
+    protected cancelSaveMask(): void;
     private finishMask;
     private maskError;
-    private teardownMaskWorker;
-    persistRegions(): void;
-    /**
-     * Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
-     * Groups the store's per-slice regions by slice index and serializes each on
-     * the default plane (z=0) — each slice-file is itself one plane, and the
-     * loader re-derives the slice index from the file's position in the series.
-     * Slices cleared since load are included (empty) so their file is overwritten.
-     */
+    protected persistRegions(): void;
+    /** Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
+     *  No dialog covers the toolbar meanwhile, so a Save while one is uploading
+     *  is ignored rather than starting a second write (and orphaning the first). */
     private saveStackSlices;
-    checkSaveAsFileExists(): void;
-    confirmSaveAs(): void;
+    protected checkSaveAsFileExists(): void;
+    protected confirmSaveAs(): void;
     /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or
      *  the in-flight upload, and reset state. */
-    cancelSaveAs(): void;
+    protected cancelSaveAs(): void;
+    private toast;
     static ɵfac: i0.ɵɵFactoryDeclaration<RegionEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorComponent, "region-editor", never, {}, {}, never, never, false, 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

@@ -0,0 +1,34 @@
+import { Region } from '../models/region';
+import { IImageMetadata } from '../contracts/image.contract';
+/** Physical pixel size (µm/pixel); both undefined when the image is unscaled. */
+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
+ * calibration may sit on any channel entry, not necessarily [0], so take the
+ * first entry with a positive mppX (as PlotlyService.currentMpp does). With
+ * only one axis reported, pixels are square (mppY = mppX), so a scaled image
+ * shows µm²/mm² rather than px².
+ */
+export declare function pickMpp(meta: IImageMetadata[] | undefined): PixelSize;
+/**
+ * A region's area in px²: width·height for a rectangle, shoelace for a polygon
+ * with each interior ring (hole) subtracted (a donut reports the annulus), and
+ * the sum of the parts for a multi-polygon (jit-ui#85). 0 for anything else.
+ */
+export declare function regionAreaPx(region: Pick<Region, 'bounds'>): number;
+/**
+ * An area for display: µm² (mm² from 1e6 µm²) when the pixel size is known,
+ * 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;