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

package/lib/plot-mode/tool-params-model.d.ts

@@ -0,0 +1,49 @@
+import { NumberParamSpec, SelectParamSpec, ToolParamSpec, ToolbarToolContribution } from '../contracts/toolbar-tool.contract';
+/** The open parameter dialog, as its template binds it. */
+export interface OpenToolParams {
+    tool: ToolbarToolContribution;
+    /** The tool's live values; the dialog edits them in place. */
+    values: Record<string, unknown>;
+    /** Each field's spec, already narrowed for the template (an `*ngSwitchCase` does not
+     *  narrow a union in the template type checker). */
+    fields: {
+        spec: ToolParamSpec;
+        number: NumberParamSpec | null;
+        select: SelectParamSpec | null;
+    }[];
+}
+/**
+ * Checkpoint choice and parameter values of the contributed no-prompt tools
+ * (`TOOLBAR_TOOLS`), and the generic parameter dialog over them.
+ *
+ * Values are seeded from the tool's defaults with the active checkpoint's own
+ * `ToolModelOption.defaults` on top — they encode the scale and crowding the
+ * checkpoint was trained for — lazily, on first use, and re-seeded when the
+ * checkpoint changes or the user resets.
+ */
+export declare class ToolParamsModel {
+    readonly tools: ToolbarToolContribution[];
+    /** Active checkpoint per tool; replaced (not mutated) so the toolbar sees a new reference. */
+    toolModelIds: Record<string, string>;
+    /** Parameter values per tool. */
+    toolParams: Record<string, Record<string, unknown>>;
+    /** The open dialog, built once on open so change detection only reads properties. Null while closed. */
+    openParams: OpenToolParams | null;
+    constructor(tools: ToolbarToolContribution[]);
+    /** A tool's current values, seeded on first use. */
+    paramsFor(toolId: string): Record<string, unknown>;
+    /** Active checkpoint for a tool, falling back to the tool's own default. */
+    modelIdFor(tool: ToolbarToolContribution): string;
+    /** Switching checkpoint re-seeds the parameters: the defaults belong to the model. */
+    setModel(toolId: string, modelId: string): void;
+    reset(toolId: string): void;
+    open(toolId: string): void;
+    close(): void;
+    /** The values to run a tool with: its parameters plus the active checkpoint. */
+    runParams(tool: ToolbarToolContribution): Record<string, unknown>;
+    find(toolId: string): ToolbarToolContribution | undefined;
+    /** A tool's defaults for a checkpoint, with that checkpoint's own overrides on top. */
+    private seed;
+    /** A tool's values object was replaced: point an open dialog for it at the new one. */
+    private rebind;
+}

package/lib/plot.utilities.d.ts

@@ -3,13 +3,19 @@ import { ShapeSelection } from './models/shape';
 export declare const COLORMAP_OPTIONS: {
     label: string;
     data: null;
-    children: {
+    children: ({
+        label: string;
+        data: {
+            value: [number, string][];
+            src: string;
+        };
+    } | {
         label: string;
         data: {
             value: string;
             src: string;
         };
-    }[];
+    })[];
 }[];
 export declare const CONFIG: {
     displaylogo: boolean;
@@ -45,7 +51,9 @@ export declare class PlotUtilities {
      */
     getRectangle(coordinates: number[], trueImageSize: number[]): Rectangle;
     /**
-     * given a dom object (found by id), return a Rectangle of the bounding element.
+     * The on-screen box a plot div is laid out in: the bounding rectangle of the
+     * element with id `div`'s parent (callers pass the plot div's own id). An
+     * empty Rectangle when there is no such element or it has no parent.
      * @param div
      */
     getDomRectangle(div: string): Rectangle;
@@ -61,47 +69,28 @@ export declare class PlotUtilities {
      */
     getPolygon(fig: any): any;
     /**
-     * TESTED
      * Rounds a list of numbers
      * @param a
      */
     round(a: number[]): number[];
     /**
-     * TESTED
-     * Returns true of zoom is the same as image size
+     * Returns true if the zoom is the same as the image size
      * @param rect Rectangle area
      * @param trueImgSize
      * @return true if rect is out of image size boundary
      */
     isZoomSameAsImgSize(rect: Rectangle, trueImgSize: number[]): boolean;
     /**
-     * Save the json string to a file
-     * @param jsonString
-     */
-    saveToFile(jsonString: any, baseName?: string): void;
-    /**
-     * Function that imports ROIs from a geojson object
-     * @param geoJsonStr
-     * @return Region[]
+     * Download a GeoJSON string as `<baseName without extension>.geojson`
+     * (`rois.geojson` without a base name).
      */
+    saveToFile(jsonString: string, baseName?: string): void;
+    /** Parse GeoJSON into regions; see {@link regionsFromGeoJson} in `models/region-geojson`. */
     importROIsFromGeoJson(geoJsonStr: string): Region[];
-    /**
-     * Function that returns a geojson object from a Plotly ROI
-     * @param rois
-     * @return FeatureCollection<Geometry, GeoJsonProperties>
-     */
+    /** Serialise regions as GeoJSON; see {@link regionsToGeoJson} in `models/region-geojson`. */
     exportROIsToGeoJson(rois: Region[]): string;
-    /**
-     * Convert GeoJSON interior rings into the neutral hole representation
-     * (`number[][]` per ring, no repeated closing point). Degenerate rings (< 3
-     * distinct points) are dropped. jit-ui#85.
-     */
-    /**
-     * Build a closed {@link Polygon} from a GeoJSON ring set: `rings[0]` is the
-     * exterior (closing point dropped), `rings[1..]` are interior holes. jit-ui#85.
-     */
-    private polygonFromRings;
-    private ringsToHoles;
+    /** `#rrggbb` for an RGB triple; see {@link rgbToHex} in `contracts/color`. */
     rgbToHex(r: number, g: number, b: number): string;
+    /** RGB for a hex colour (`#rgb` / `#rrggbb`); black when missing or unparseable. */
     hexToRgb(hex: string | undefined): number[];
 }

package/lib/processing/processing-image.d.ts

@@ -10,8 +10,11 @@ export declare class ProcessingImage {
     /** Create from browser ImageData. */
     static fromImageData(imageData: ImageData): ProcessingImage;
     constructor(width: number, height: number, channels: number, data: Uint8ClampedArray);
-    /** Convert to browser-native ImageData (RGBA). */
+    /**
+     * Convert to browser-native ImageData (RGBA). Gray (1), gray+alpha (2) and
+     * RGB (3) are expanded; other channel counts throw.
+     */
     toImageData(): ImageData;
-    /** Convert to Blob for saving/downloading. */
+    /** Convert to Blob for saving/downloading. Rejects when the browser can't encode it. */
     toBlob(mime?: string): Promise<Blob>;
 }

package/lib/provide-visualization.d.ts

@@ -1,4 +1,11 @@
 import { Provider } from '@angular/core';
+/**
+ * The three host-facing contracts, all served by the router. Shared by
+ * {@link provideVisualization} (component scope) and `VisualizationModule` (root),
+ * so both bind them the same way; at each scope they resolve to that scope's router.
+ * Package-internal (not exported from the public API).
+ */
+export declare const VISUALIZER_TOKEN_BINDINGS: Provider[];
 /**
  * A self-contained, isolated visualization backend chain for a component subtree.
  *
@@ -26,9 +33,19 @@ import { Provider } from '@angular/core';
  * embedded viewer gets its own router/Plotly/OSD/stores/tools while the rest of the
  * app keeps the default root instance.
  *
+ * In an application's own providers (`bootstrapApplication(App, { providers: [
+ * provideVisualization(), …] })`) it binds the one app-wide chain instead — the
+ * standalone counterpart of importing the deprecated `VisualizationModule`.
+ *
  * Lists EVERY stateful service in the chain. Stateless collaborators (HttpClient,
  * MessageService, WandService) deliberately resolve to root — they hold no
- * per-viewer state, so sharing them is correct and keeps this list minimal. When a
- * new stateful service joins the rendering chain, add it here too.
+ * per-viewer state, so sharing them is correct and keeps this list minimal. The
+ * SAM model session (`SamSessionService`) is also root on purpose: every viewer's
+ * SAM tools share one model download and Worker/GPU session (see its doc; a host
+ * can provide it at a viewer component to get a per-viewer session that is
+ * disposed with the viewer). When a
+ * new stateful service joins the rendering chain, add it here too —
+ * `provide-visualization.spec.ts` fails until it is listed (or allow-listed there as
+ * deliberately shared).
  */
 export declare function provideVisualization(): Provider[];

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

@@ -0,0 +1,56 @@
+import { EventEmitter, OnChanges } 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. */
+interface ClassRow {
+    name: string;
+    color: string;
+    count: number;
+    canRemove: boolean;
+    rowTooltip: string;
+    removeTooltip: string;
+}
+/**
+ * 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.
+ */
+export declare class ClassesPanelComponent implements OnChanges {
+    /** The classes in display order. */
+    classes: ClassPreset[];
+    /** Region count per class, keyed by {@link presetKey} under `matchMode`. */
+    counts: Map<string, number>;
+    /** How labels are matched to classes (keys {@link counts}). */
+    matchMode: MatchMode;
+    /** The active class (highlighted), or null. */
+    activeClass: string | null;
+    /** 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;
+    /** A row was clicked: make the class active / apply it to the selection. */
+    pick: EventEmitter<string>;
+    /** A class's swatch picked a new colour. */
+    recolor: EventEmitter<{
+        name: string;
+        color: string;
+    }>;
+    /** A class's trash button (its name). */
+    remove: EventEmitter<string>;
+    /** Manage clicked. */
+    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. */
+    protected rows: ClassRow[];
+    ngOnChanges(): void;
+    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>;
+}
+export {};

package/lib/region-editor/file-stem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A file name without its extension: `slide.ome.tif` → `slide.ome`. A name with
+ * no extension — or only a leading dot, like `.hidden` — is returned whole, so
+ * a derived name is never a bare `.geojson`. `fallback` stands in for a missing
+ * name.
+ */
+export declare function fileStem(name: string | null | undefined, fallback: string): string;

package/lib/region-editor/manage-classes-dialog/manage-classes-dialog.component.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '@angular/core';
+import { ClassPreset, MatchMode, PresetSet } from '../../models/class-preset';
+import * as i0 from "@angular/core";
+/**
+ * "Manage annotation classes" (jit-ui#70): edit the classes, the fallback
+ * palette, auto-add and label matching of a working copy of the preset set,
+ * plus reset / import / export. The editor owns the draft (`[(draft)]`); every
+ * edit here emits a new draft object (nothing is changed in place), and Apply
+ * asks the editor to persist it.
+ */
+export declare class ManageClassesDialogComponent {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** The working copy being edited (null until the dialog is opened). */
+    draft: PresetSet | null;
+    /** Every edit: the new draft object; two-way with {@link draft}. */
+    draftChange: EventEmitter<PresetSet>;
+    /** Apply clicked: persist the draft and close. */
+    apply: EventEmitter<void>;
+    /** Reset clicked: restore the default classes. */
+    resetDefaults: EventEmitter<void>;
+    /** A preset JSON file was chosen (the input's change event). */
+    importFile: EventEmitter<Event>;
+    /** Export clicked. */
+    export: EventEmitter<void>;
+    protected readonly matchModeOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** Rows keep their DOM (and input focus) while their class object is replaced. */
+    protected readonly trackByIndex: (i: number) => number;
+    protected addClass(): void;
+    protected removeClass(i: number): void;
+    protected patchClass(i: number, patch: Partial<ClassPreset>): void;
+    protected addFallbackColor(): void;
+    protected removeFallbackColor(i: number): void;
+    protected setFallbackColor(i: number, color: string): void;
+    protected setAutoPromote(autoPromote: boolean): void;
+    protected setMatchMode(matchMode: MatchMode): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManageClassesDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ManageClassesDialogComponent, "region-manage-classes-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "draft": { "alias": "draft"; "required": false; }; }, { "visibleChange": "visibleChange"; "draftChange": "draftChange"; "apply": "apply"; "resetDefaults": "resetDefaults"; "importFile": "importFile"; "export": "export"; }, never, never, true, never>;
+}

package/lib/region-editor/mask-export.service.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { Region } from '../models/region';
+import * as i0 from "@angular/core";
+/** Mask type: one foreground value, or a distinct id per region. */
+export type MaskMode = 'binary' | 'multiclass';
+/** What to rasterize, at the full image size. */
+export interface MaskExportRequest {
+    regions: Region[];
+    imageSize: {
+        width: number;
+        height: number;
+    };
+    mode: MaskMode;
+    /** Recorded in the PNG metadata. */
+    sourceName?: string;
+}
+/** Progress of one mask export, in order: planned → progress* → encoding → done. */
+export type MaskExportEvent = 
+/** The mask size; `scale` < 1 when the image exceeds the pixel budget. */
+{
+    type: 'planned';
+    width: number;
+    height: number;
+    scale: number;
+}
+/** 0–100 rasterization progress. */
+ | {
+    type: 'progress';
+    percent: number;
+}
+/** Rasterizing finished; the PNG is being encoded. */
+ | {
+    type: 'encoding';
+} | {
+    type: 'done';
+    blob: Blob;
+};
+/**
+ * Rasterizes regions to a label-mask PNG in a Web Worker (jit-ui#95), so the
+ * full-resolution rasterize and PNG encode never freeze the UI and the job can
+ * be cancelled. Component-agnostic: {@link export} returns a cold Observable —
+ * subscribing starts a worker, unsubscribing terminates it (cancel), and a
+ * worker failure is an error carrying a user-facing message. Whole-slide
+ * images are capped to a safe pixel budget (the geometry is scaled to match).
+ */
+export declare class MaskExportService {
+    export(request: MaskExportRequest): Observable<MaskExportEvent>;
+    /** Worker factory: a dynamic import, so the worker module (and its
+     *  `import.meta.url`, which the CommonJS test compile rejects) loads lazily.
+     *  Overridable in tests. */
+    protected createWorker(): Promise<Worker>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaskExportService>;
+}

package/lib/region-editor/mask-raster.d.ts

@@ -1,4 +1,6 @@
 import { Region } from '../models/region';
+import type { BBoxMask } from '../geometry/raster';
+export type { BBoxMask };
 /** A single closed ring (+ optional holes) in image-pixel coordinates. A region
  *  rasterizes as the union of its parts. Plain data so it survives a
  *  `postMessage` structured clone into the mask worker. */
@@ -7,14 +9,6 @@ export interface MaskPart {
     ypoints: number[];
     holes?: number[][][];
 }
-/** A bbox-relative binary mask, as returned by `WandService.rasterizePolygon`. */
-export interface BBoxMask {
-    bx: number;
-    by: number;
-    bw: number;
-    bh: number;
-    mask: Uint8Array;
-}
 /** Polygon-fill function (the wand's scanline rasterizer), injected so this
  *  module stays free of Angular/DOM and can run inside a worker. */
 export type RasterizeFn = (xpoints: number[], ypoints: number[], imageWidth: number, imageHeight: number, holes?: number[][][]) => BBoxMask | null;

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

@@ -0,0 +1,29 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/** One class's colour in the dialog; `label` '' groups unclassified regions. */
+export interface ClassColorEdit {
+    label: string;
+    color: string;
+}
+/**
+ * "Edit colour of selected regions": one picker per class among the selection.
+ * Edits a private copy of `edits` and reports the result on Apply; the editor
+ * applies it to the regions (copy-on-write) and commits.
+ */
+export declare class RegionColorDialogComponent {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    /** Number of selected regions, for the caption. */
+    selectedCount: number;
+    /** The seeded colours; the dialog edits a copy. */
+    set edits(value: ClassColorEdit[] | null | undefined);
+    /** Apply clicked: the edited colours per class. */
+    apply: EventEmitter<ClassColorEdit[]>;
+    protected draft: ClassColorEdit[];
+    protected setColor(i: number, color: string): void;
+    protected close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionColorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionColorDialogComponent, "region-color-dialog", never, { "visible": { "alias": "visible"; "required": false; }; "selectedCount": { "alias": "selectedCount"; "required": false; }; "edits": { "alias": "edits"; "required": false; }; }, { "visibleChange": "visibleChange"; "apply": "apply"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/** The Region Editor's help dialog (static content). */
+export declare class RegionEditorHelpComponent {
+    /** The dialog is open. */
+    visible: boolean;
+    /** The dialog was closed (`false`); two-way with {@link visible}. */
+    visibleChange: EventEmitter<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegionEditorHelpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RegionEditorHelpComponent, "region-editor-help", never, { "visible": { "alias": "visible"; "required": false; }; }, { "visibleChange": "visibleChange"; }, never, never, true, never>;
+}