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

package/lib/region-editor/class-tree/class-tree.d.ts

@@ -0,0 +1,31 @@
+import type { RegionClassNode } from '../../region-source/region-tiles';
+/** A class hierarchy as a tree: children in order, subtree counts, depths. Pure. */
+export interface ClassTree {
+    roots: string[];
+    node: Map<string, RegionClassNode>;
+    children: Map<string, string[]>;
+    parent: Map<string, string | null>;
+    /** Regions of the class and every class under it. */
+    total: Map<string, number>;
+}
+/**
+ * Build the tree of `nodes`, counting `counts` (regions per class) up through it. A node whose
+ * parent is not in the hierarchy is a root; siblings sort by `order`, then as listed.
+ */
+export declare function buildClassTree(nodes: readonly RegionClassNode[], counts: ReadonlyMap<string, number>): ClassTree;
+/** `name` and every class under it. */
+export declare function subtree(tree: ClassTree, name: string): string[];
+/** The classes from the root down to `name`'s parent. */
+export declare function ancestors(tree: ClassTree, name: string): string[];
+/** One visible row of the tree. */
+export interface ClassTreeRow {
+    name: string;
+    depth: number;
+    hasChildren: boolean;
+    expanded: boolean;
+}
+/**
+ * The rows to draw: depth-first through the expanded nodes. With a `query`, only the nodes whose
+ * name or title contains it and their ancestors, all expanded.
+ */
+export declare function visibleRows(tree: ClassTree, expanded: ReadonlySet<string>, query?: string): ClassTreeRow[];

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

@@ -1,4 +1,4 @@
-import { EventEmitter, OnChanges } from '@angular/core';
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
 import { ClassPreset, MatchMode } from '../../models/class-preset';
 import * as i0 from "@angular/core";
 /** One class row as the template draws it, derived once per input change. */
@@ -14,10 +14,13 @@ interface ClassRow {
  * The Region Editor's docked "Classes" panel (jit-ui#70): every annotation
  * class with its colour swatch and region count. A row click picks the active
  * class (and re-classifies a selection), the swatch recolours the class, the
- * trash removes it, Manage opens the full editor. Presentational: the editor
- * applies every action.
+ * trash removes it, Manage opens the full editor; the search box filters the
+ * rows by name; the eye hides a class's regions. For a class hierarchy the editor projects a class tree in,
+ * shown in place of the list while {@link treeView} is on. Presentational: the
+ * editor applies every action.
  */
 export declare class ClassesPanelComponent implements OnChanges {
+    private readonly el;
     /** The classes in display order. */
     classes: ClassPreset[];
     /** Region count per class, keyed by {@link presetKey} under `matchMode`. */
@@ -26,10 +29,28 @@ export declare class ClassesPanelComponent implements OnChanges {
     matchMode: MatchMode;
     /** The active class (highlighted), or null. */
     activeClass: string | null;
+    /** The class picked last (in the class tree, or a surface in 3D): highlighted, scrolled into view. */
+    picked: string | null;
+    /** Classes with a selected region (marked). */
+    marked: ReadonlySet<string>;
     /** Number of selected regions (changes what a row click does). */
     selectedCount: number;
     /** The class regions revert to; it can't be removed while in use. */
     defaultClassName: string;
+    /** Whether a volume view is on screen: each class can then be shown in 3D. */
+    volume: boolean;
+    /** The classes shown in 3D. */
+    shown3d: ReadonlySet<string>;
+    /** The classes hidden from view. */
+    hidden: ReadonlySet<string>;
+    /** A class's eye (its name): hide it, or show it again. */
+    toggleHidden: EventEmitter<string>;
+    /** A class's 3D toggle (its name). */
+    toggle3d: EventEmitter<string>;
+    /** Whether the projected class tree is shown instead of the list; null: there is no tree. */
+    treeView: boolean | null;
+    /** The list / tree switch. */
+    treeViewChange: EventEmitter<boolean>;
     /** A row was clicked: make the class active / apply it to the selection. */
     pick: EventEmitter<string>;
     /** A class's swatch picked a new colour. */
@@ -43,14 +64,23 @@ export declare class ClassesPanelComponent implements OnChanges {
     manage: EventEmitter<void>;
     /** trackBy for the class rows so re-sorting doesn't re-create the pickers. */
     protected readonly trackByName: (_: number, c: ClassRow) => string;
-    /** The rows drawn, rebuilt when an input changes rather than per check. */
+    /** Every class's row, rebuilt when an input changes rather than per check. */
     protected rows: ClassRow[];
-    ngOnChanges(): void;
+    /** The rows matching {@link query}. */
+    protected shownRows: ClassRow[];
+    /** The search box's text. */
+    protected query: string;
+    constructor(el: ElementRef<HTMLElement>);
+    ngOnChanges(changes?: SimpleChanges): void;
+    protected onQuery(value: string): void;
+    /** Enter in the search box picks the first match. */
+    protected pickFirstMatch(): void;
+    private filter;
     private count;
     private canRemove;
     protected rowTooltip(name: string): string;
     protected removeTooltip(name: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<ClassesPanelComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ClassesPanelComponent, "region-classes-panel", never, { "classes": { "alias": "classes"; "required": false; }; "counts": { "alias": "counts"; "required": false; }; "matchMode": { "alias": "matchMode"; "required": false; }; "activeClass": { "alias": "activeClass"; "required": false; }; "selectedCount": { "alias": "selectedCount"; "required": false; }; "defaultClassName": { "alias": "defaultClassName"; "required": false; }; }, { "pick": "pick"; "recolor": "recolor"; "remove": "remove"; "manage": "manage"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ClassesPanelComponent, "region-classes-panel", never, { "classes": { "alias": "classes"; "required": false; }; "counts": { "alias": "counts"; "required": false; }; "matchMode": { "alias": "matchMode"; "required": false; }; "activeClass": { "alias": "activeClass"; "required": false; }; "picked": { "alias": "picked"; "required": false; }; "marked": { "alias": "marked"; "required": false; }; "selectedCount": { "alias": "selectedCount"; "required": false; }; "defaultClassName": { "alias": "defaultClassName"; "required": false; }; "volume": { "alias": "volume"; "required": false; }; "shown3d": { "alias": "shown3d"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "treeView": { "alias": "treeView"; "required": false; }; }, { "toggleHidden": "toggleHidden"; "toggle3d": "toggle3d"; "treeViewChange": "treeViewChange"; "pick": "pick"; "recolor": "recolor"; "remove": "remove"; "manage": "manage"; }, never, ["*"], true, never>;
 }
 export {};

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,16 @@ 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;
+    /** The host's HttpClient: a served region set's requests go through it (its auth). */
+    private readonly http;
     protected regions: Region[];
     protected selectedRegions: Region[];
     protected showShapeLabel: boolean;
@@ -62,6 +64,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 +167,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 +252,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 +306,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;
@@ -236,8 +350,36 @@ export declare class RegionEditorComponent implements OnInit, OnDestroy {
     protected importPresets(event: Event): void;
     /** Validate and apply an imported annotation-classes JSON file. */
     private applyImportedPresets;
+    /** The files chosen in the import inputs: one GeoJSON, a label volume with its ontology, or a
+     *  folder of per-slice GeoJSON files. */
     protected importRois(event: Event): void;
-    /** Replace the regions with an imported GeoJSON file's. */
+    /** Whether the host can pick regions on its server ("Import regions from server"). */
+    protected get canImportFromServer(): boolean;
+    /** An import from the server is in flight. */
+    protected importing: boolean;
+    /** "Import regions from server": the host picks files or a served region set; they import as chosen files do. */
+    protected importFromServer(): void;
+    /**
+     * Import `files` (see planRegionImport): one GeoJSON file as before; a label volume as one
+     * region source per slice, traced from it the first time the slice is shown, its classes named
+     * (and treed) by the ontology chosen with it; a folder as one source per slice file. Either
+     * replaces the regions and sources of every slice.
+     */
+    private importRegionFiles;
+    /** A region set the host's server serves (jit-service's /regions/{id}/), read through its HttpClient. */
+    private importServedRegionSet;
+    /** An import that finished after another image was shown (or another import began): dropped. */
+    private importStale;
+    /** The table and selection after the regions were replaced by imported sources. */
+    private afterSourceImport;
+    /** Warn when an imported volume's slices are not the image's size: its outlines would not fit. */
+    private warnIfSizeDiffers;
+    private importFailed;
+    /**
+     * 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 +410,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

@@ -1,7 +1,7 @@
 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 { RegionIoPort, ServerRegionPick } 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 {
@@ -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,15 @@ 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[]>;
+    /** Whether the host can pick regions on its server (see RegionIoPort.pickServerRegions). */
+    canPickServerRegions(): boolean;
+    /** Let the user pick regions on the host's server; null when cancelled or unsupported. */
+    pickServerRegions(): Observable<ServerRegionPick | null>;
     /** 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-import/label-classes.d.ts

@@ -0,0 +1,39 @@
+import type { RegionClassNode, RegionSourceStyle } from '../region-source/region-tiles';
+import type { LabelVolume } from './label-volume';
+/**
+ * The classes of a label volume's values: their names and colours and, when the volume comes
+ * with an ontology, their tree. Pure.
+ */
+export interface LabelClasses {
+    /** The class of label `value` (> 0); one without an ontology entry is `label <value>`. */
+    classOf(value: number): {
+        name: string;
+        color: string;
+        title?: string;
+    };
+    /** The class tree, when the ontology has one. */
+    hierarchy?: RegionClassNode[];
+    /** How the set wants to be drawn (an atlas's filled look), when the ontology says. */
+    style?: RegionSourceStyle;
+}
+/** The look the Allen atlas region sets carry (see the brain-atlas example's GeoJSON). */
+export declare const ATLAS_STYLE: RegionSourceStyle;
+/**
+ * The classes of a label volume from `ontology`, a parsed JSON document:
+ *
+ * - an **Allen structure graph** (`structure_graph_1.json`: `{ msg: [root] }`, or a node or a
+ *   list of nodes with `id`, `acronym`, `name`, `color_hex_triplet`, `graph_order` and
+ *   `children`): label = structure id, class = acronym, its tree the ontology's, drawn as the
+ *   atlas region sets are;
+ * - a **region set description** (a `regionset.json`: `classHierarchy`, optional `style`), whose
+ *   classes name their label as `value` (or `id`), or with a `labels` map of value → class name.
+ *
+ * Without one (or with another document), each label is its own class `label <value>`.
+ */
+export declare function labelClasses(ontology?: unknown): LabelClasses;
+/**
+ * Slice `z` of `volume` as a GeoJSON FeatureCollection string: one feature per label on the
+ * slice, its every piece (with holes) traced along pixel edges, in image pixels with y down;
+ * classified by `classes`, which also give the collection its class tree and style.
+ */
+export declare function labelSliceGeoJson(volume: LabelVolume, z: number, classes: LabelClasses): string;

package/lib/region-import/label-volume.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A label volume (a NIfTI-1 `.nii` / `.nii.gz` or a NRRD `.nrrd` of integer structure ids, an
+ * atlas annotation say) read in the browser, sliced as the server opens the matching image:
+ *
+ * - **NRRD**: a 3D volume is cut along its FIRST axis, each section its third axis wide and its
+ *   second axis high, as jit-service opens a NRRD volume (`AtlasNrrdReader`: the Allen CCF's 528
+ *   coronal sections of 456 × 320, anterior first). A 2D NRRD is one slice.
+ * - **NIfTI**: along its third axis, each slice its first axis wide and its second axis high, as
+ *   Bio-Formats reads one (no row flip).
+ *
+ * Only what label volumes use: a single file (NRRD with attached data, NIfTI-1 `n+1`), integer
+ * or integer-valued float samples, either byte order, raw or gzip. Anything else throws rather
+ * than be read approximately. Pure: usable from workers.
+ */
+/** A label volume, sliced (see the module comment). Label 0 is background. */
+export interface LabelVolume {
+    format: 'nrrd' | 'nifti';
+    /** A slice's width and height, in voxels (the image's pixels). */
+    width: number;
+    height: number;
+    /** Number of slices. */
+    slices: number;
+    /** Slice `z`'s labels, row-major (`height` rows of `width`). */
+    sliceLabels(z: number): Uint32Array;
+}
+/** Decompress gzip bytes (default: the platform's `DecompressionStream`). */
+export type Gunzip = (bytes: Uint8Array) => Promise<Uint8Array>;
+/** Whether a file name is a label volume this reads. */
+export declare function isLabelVolumeName(name: string): boolean;
+/** Read the label volume in `bytes`, named `name` (`.nrrd`, `.nii`, `.nii.gz`). */
+export declare function readLabelVolume(name: string, bytes: Uint8Array, gunzip?: Gunzip): Promise<LabelVolume>;

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

@@ -0,0 +1,46 @@
+/** A file to import regions from: one the user chose, or one the host's server sent. */
+export interface RegionImportFile {
+    name: string;
+    text(): Promise<string>;
+    bytes(): Promise<Uint8Array>;
+}
+/** A file's contents as the host may hand them over (see `ServerRegionPick`). */
+export type RegionImportData = Blob | ArrayBuffer | Uint8Array | string;
+/** `data`, named `name`, as an import file. A `File`'s own name is used when `name` is omitted. */
+export declare function importFile(data: RegionImportData, name?: string): RegionImportFile;
+/** What a set of chosen files imports as. */
+export type RegionImportPlan = 
+/** A label volume, its classes named by an ontology (or a region set description) beside it. */
+{
+    kind: 'volume';
+    volume: RegionImportFile;
+    ontology: RegionImportFile | null;
+}
+/** A folder of per-slice region files, in slice order, with the set's `regionset.json`. */
+ | {
+    kind: 'folder';
+    slices: RegionImportFile[];
+    regionSet: RegionImportFile | null;
+}
+/** One region file. */
+ | {
+    kind: 'single';
+    file: RegionImportFile;
+};
+/**
+ * What `files` import as: a label volume (`.nii`, `.nii.gz`, `.nrrd`) with the ontology JSON chosen
+ * with it (a `regionset.json`, else an Allen `structure_graph*.json`, else any `.json`); several
+ * region files (a folder of per-slice `.geojson`, in natural name order, its `regionset.json`
+ * apart); or one region file (`.geojson` or `.json`). Null when none of them is one.
+ */
+export declare function planRegionImport(files: readonly RegionImportFile[]): RegionImportPlan | null;
+/** "slice_2" before "slice_10": runs of digits compared as numbers. */
+export declare function naturalCompare(a: string, b: string): number;
+/**
+ * A folder slice's GeoJSON with the set's class tree and style (its `regionset.json`) as the
+ * collection's own members, unless the file has its own: what a served folder's slice carries.
+ */
+export declare function folderSliceGeoJson(file: RegionImportFile, regionSet: {
+    classHierarchy?: unknown;
+    style?: unknown;
+} | null): Promise<string>;

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 {