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

package/esm2022/lib/visualizer/floating-drag.directive.mjs

@@ -0,0 +1,58 @@
+import { Directive, EventEmitter, HostListener, Input, NgZone, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Drag handle of a floating, `position: fixed` panel (the intensity inset header,
+ * the toolbar dock handle). On mousedown it asks {@link origin} where the panel is —
+ * the host may detach a docked panel right there — then emits the new position on
+ * every move until mouseup.
+ *
+ * The move/up listeners exist only while a drag is in progress and run outside the
+ * Angular zone, re-entering it per emitted position: a permanent window mousemove
+ * listener made every pointer move anywhere in the host app run change detection.
+ */
+export class FloatingDragDirective {
+    constructor(zone) {
+        this.zone = zone;
+        /** The panel's new position, per pointer move. */
+        this.vizFloatingDragMove = new EventEmitter();
+        this.end = null;
+    }
+    onMouseDown(e) {
+        e.preventDefault();
+        this.end?.();
+        const from = this.origin();
+        const start = { mx: e.clientX, my: e.clientY, x: from.x, y: from.y };
+        const move = (ev) => this.zone.run(() => this.vizFloatingDragMove.emit({
+            x: start.x + (ev.clientX - start.mx),
+            y: start.y + (ev.clientY - start.my),
+        }));
+        const up = () => this.end?.();
+        this.zone.runOutsideAngular(() => {
+            window.addEventListener('mousemove', move);
+            window.addEventListener('mouseup', up);
+        });
+        this.end = () => {
+            window.removeEventListener('mousemove', move);
+            window.removeEventListener('mouseup', up);
+            this.end = null;
+        };
+    }
+    ngOnDestroy() {
+        this.end?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: FloatingDragDirective, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.9", type: FloatingDragDirective, isStandalone: true, selector: "[vizFloatingDrag]", inputs: { origin: ["vizFloatingDrag", "origin"] }, outputs: { vizFloatingDragMove: "vizFloatingDragMove" }, host: { listeners: { "mousedown": "onMouseDown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: FloatingDragDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[vizFloatingDrag]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.NgZone }], propDecorators: { origin: [{
+                type: Input,
+                args: ['vizFloatingDrag']
+            }], vizFloatingDragMove: [{
+                type: Output
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/visualizer/region-actions.mjs

@@ -0,0 +1,149 @@
+import { takeUntil } from 'rxjs/operators';
+import { MultiPolygon, Polygon, Rectangle } from '../models/region';
+import { opEligible, regionsAt } from './visualizer-context-menu';
+/**
+ * Region set-operations on the current selection (jit-ui#85) — select all, merge,
+ * ungroup, inverse, simplify — plus the store mirrors the toolbar and the context
+ * menu read synchronously: the selection and the undo/redo availability.
+ *
+ * Every operation commits through `setRegions`, so it is undo-tracked and the
+ * backend on screen re-renders; profile lines and unselected regions are kept.
+ */
+export class RegionActions {
+    constructor(target, ops, 
+    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */
+    imageSize, notify) {
+        this.target = target;
+        this.ops = ops;
+        this.imageSize = imageSize;
+        this.notify = notify;
+        /** Current selection (array indices), mirrored from the store. */
+        this.selectedIndices = [];
+        /** Whether a region action is available to undo / redo; drive the toolbar buttons. */
+        this.canUndo = false;
+        this.canRedo = false;
+        /** Custom-threshold Simplify dialog. */
+        this.displaySimplifyDialog = false;
+        this.simplifyThreshold = 3;
+    }
+    /** Mirror the store's selection and undo/redo depth until `until$` emits.
+     *  `changed` runs after an undo/redo flip (the toolbar binds those). */
+    bind(until$, changed) {
+        this.target
+            .getCanUndo$()
+            .pipe(takeUntil(until$))
+            .subscribe((v) => {
+            this.canUndo = v;
+            changed();
+        });
+        this.target
+            .getCanRedo$()
+            .pipe(takeUntil(until$))
+            .subscribe((v) => {
+            this.canRedo = v;
+            changed();
+        });
+        this.target
+            .getSelectedShapeIndices$()
+            .pipe(takeUntil(until$))
+            .subscribe((indices) => {
+            this.selectedIndices = indices || [];
+        });
+    }
+    /** The currently-selected regions (live store instances). */
+    get selected() {
+        return regionsAt(this.target.getRegions(), this.selectedIndices);
+    }
+    /** Select every region on the image (excludes intensity-profile lines). */
+    selectAll() {
+        const indices = [];
+        this.target.getRegions().forEach((r, i) => {
+            if (r.kind !== 'profile')
+                indices.push(i);
+        });
+        this.target.setSelectedShapeIndices(indices);
+    }
+    /** Merge the selected regions into a single (possibly multi-part) region. */
+    merge() {
+        const sel = opEligible(this.selected);
+        if (sel.length < 2)
+            return;
+        const { w, h } = this.frame(sel);
+        const merged = this.ops.merge(sel, w, h);
+        if (merged)
+            this.replace(sel, [merged]);
+    }
+    /** Split each selected multi-part region into one region per part. */
+    ungroup() {
+        const sel = this.selected.filter((r) => this.ops.canUngroup(r));
+        if (sel.length === 0)
+            return;
+        this.replace(sel, sel.flatMap((r) => this.ops.ungroup(r)));
+    }
+    /** Replace the selection with its inverse inside the image rectangle. */
+    inverse() {
+        const sel = opEligible(this.selected);
+        if (sel.length === 0)
+            return;
+        const { w, h } = this.frame(sel);
+        const inv = this.ops.inverse(sel, w, h);
+        if (!inv) {
+            this.notify({
+                severity: 'warn',
+                summary: 'Inverse',
+                detail: 'Nothing to invert — select one or more closed regions first.',
+            });
+            return;
+        }
+        this.replace(sel, [inv]);
+    }
+    /** Douglas–Peucker simplify each selected region by `thresholdPx`, closing the dialog. */
+    simplify(thresholdPx) {
+        const sel = opEligible(this.selected);
+        if (sel.length === 0)
+            return;
+        this.replace(sel, sel.map((r) => this.ops.simplify(r, thresholdPx)));
+        this.displaySimplifyDialog = false;
+    }
+    openSimplifyDialog() {
+        this.displaySimplifyDialog = true;
+    }
+    /** Commit a set-op: drop `remove`, append `add`, and select the results. */
+    replace(remove, add) {
+        if (add.length === 0)
+            return;
+        const removeSet = new Set(remove);
+        const kept = this.target.getRegions().filter((r) => !removeSet.has(r));
+        this.target.setRegions([...kept, ...add]); // mints ids on `add`, records undo
+        const stored = this.target.getRegions();
+        this.target.setSelectedShapeIndices(add.map((r) => stored.indexOf(r)).filter((i) => i >= 0));
+    }
+    /** Image pixel dimensions for the raster ops; falls back to the selection's extent
+     *  when the image size isn't known (keeps clamping sane). */
+    frame(regions) {
+        let [w, h] = this.imageSize() ?? [0, 0];
+        if (!(w > 0) || !(h > 0)) {
+            let maxX = 0, maxY = 0;
+            const scan = (xs, ys) => {
+                for (const x of xs)
+                    maxX = Math.max(maxX, x);
+                for (const y of ys)
+                    maxY = Math.max(maxY, y);
+            };
+            for (const r of regions) {
+                const b = r.bounds;
+                if (b instanceof Rectangle)
+                    scan([b.x + b.width], [b.y + b.height]);
+                else if (b instanceof Polygon)
+                    scan(b.xpoints, b.ypoints);
+                else if (b instanceof MultiPolygon)
+                    for (const p of b.polygons)
+                        scan(p.xpoints, p.ypoints);
+            }
+            w = Math.max(w, Math.ceil(maxX) + 2);
+            h = Math.max(h, Math.ceil(maxY) + 2);
+        }
+        return { w, h };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-actions.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/region-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { Message } from 'primeng/api';\n\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\nimport { RegionOpsService } from '../region-ops.service';\nimport { opEligible, regionsAt } from './visualizer-context-menu';\n\n/** The region-store members the set-operations read and write through. */\nexport type RegionActionsTarget = Pick<\n  IRegionStore,\n  | 'getRegions'\n  | 'setRegions'\n  | 'setSelectedShapeIndices'\n  | 'getSelectedShapeIndices$'\n  | 'getCanUndo$'\n  | 'getCanRedo$'\n>;\n\n/**\n * Region set-operations on the current selection (jit-ui#85) — select all, merge,\n * ungroup, inverse, simplify — plus the store mirrors the toolbar and the context\n * menu read synchronously: the selection and the undo/redo availability.\n *\n * Every operation commits through `setRegions`, so it is undo-tracked and the\n * backend on screen re-renders; profile lines and unselected regions are kept.\n */\nexport class RegionActions {\n  /** Current selection (array indices), mirrored from the store. */\n  selectedIndices: number[] = [];\n  /** Whether a region action is available to undo / redo; drive the toolbar buttons. */\n  canUndo = false;\n  canRedo = false;\n  /** Custom-threshold Simplify dialog. */\n  displaySimplifyDialog = false;\n  simplifyThreshold = 3;\n\n  constructor(\n    private readonly target: RegionActionsTarget,\n    private readonly ops: RegionOpsService,\n    /** `[width, height]` of the image, when known — the frame inverse and merge rasterize in. */\n    private readonly imageSize: () => number[] | undefined,\n    private readonly notify: (message: Message) => void,\n  ) {}\n\n  /** Mirror the store's selection and undo/redo depth until `until$` emits.\n   *  `changed` runs after an undo/redo flip (the toolbar binds those). */\n  bind(until$: Observable<unknown>, changed: () => void): void {\n    this.target\n      .getCanUndo$()\n      .pipe(takeUntil(until$))\n      .subscribe((v) => {\n        this.canUndo = v;\n        changed();\n      });\n    this.target\n      .getCanRedo$()\n      .pipe(takeUntil(until$))\n      .subscribe((v) => {\n        this.canRedo = v;\n        changed();\n      });\n    this.target\n      .getSelectedShapeIndices$()\n      .pipe(takeUntil(until$))\n      .subscribe((indices) => {\n        this.selectedIndices = indices || [];\n      });\n  }\n\n  /** The currently-selected regions (live store instances). */\n  get selected(): Region[] {\n    return regionsAt(this.target.getRegions(), this.selectedIndices);\n  }\n\n  /** Select every region on the image (excludes intensity-profile lines). */\n  selectAll(): void {\n    const indices: number[] = [];\n    this.target.getRegions().forEach((r, i) => {\n      if (r.kind !== 'profile') indices.push(i);\n    });\n    this.target.setSelectedShapeIndices(indices);\n  }\n\n  /** Merge the selected regions into a single (possibly multi-part) region. */\n  merge(): void {\n    const sel = opEligible(this.selected);\n    if (sel.length < 2) return;\n    const { w, h } = this.frame(sel);\n    const merged = this.ops.merge(sel, w, h);\n    if (merged) this.replace(sel, [merged]);\n  }\n\n  /** Split each selected multi-part region into one region per part. */\n  ungroup(): void {\n    const sel = this.selected.filter((r) => this.ops.canUngroup(r));\n    if (sel.length === 0) return;\n    this.replace(\n      sel,\n      sel.flatMap((r) => this.ops.ungroup(r)),\n    );\n  }\n\n  /** Replace the selection with its inverse inside the image rectangle. */\n  inverse(): void {\n    const sel = opEligible(this.selected);\n    if (sel.length === 0) return;\n    const { w, h } = this.frame(sel);\n    const inv = this.ops.inverse(sel, w, h);\n    if (!inv) {\n      this.notify({\n        severity: 'warn',\n        summary: 'Inverse',\n        detail: 'Nothing to invert — select one or more closed regions first.',\n      });\n      return;\n    }\n    this.replace(sel, [inv]);\n  }\n\n  /** Douglas–Peucker simplify each selected region by `thresholdPx`, closing the dialog. */\n  simplify(thresholdPx: number): void {\n    const sel = opEligible(this.selected);\n    if (sel.length === 0) return;\n    this.replace(\n      sel,\n      sel.map((r) => this.ops.simplify(r, thresholdPx)),\n    );\n    this.displaySimplifyDialog = false;\n  }\n\n  openSimplifyDialog(): void {\n    this.displaySimplifyDialog = true;\n  }\n\n  /** Commit a set-op: drop `remove`, append `add`, and select the results. */\n  private replace(remove: Region[], add: Region[]): void {\n    if (add.length === 0) return;\n    const removeSet = new Set(remove);\n    const kept = this.target.getRegions().filter((r) => !removeSet.has(r));\n    this.target.setRegions([...kept, ...add]); // mints ids on `add`, records undo\n    const stored = this.target.getRegions();\n    this.target.setSelectedShapeIndices(add.map((r) => stored.indexOf(r)).filter((i) => i >= 0));\n  }\n\n  /** Image pixel dimensions for the raster ops; falls back to the selection's extent\n   *  when the image size isn't known (keeps clamping sane). */\n  private frame(regions: Region[]): { w: number; h: number } {\n    let [w, h] = this.imageSize() ?? [0, 0];\n    if (!(w > 0) || !(h > 0)) {\n      let maxX = 0,\n        maxY = 0;\n      const scan = (xs: number[], ys: number[]) => {\n        for (const x of xs) maxX = Math.max(maxX, x);\n        for (const y of ys) maxY = Math.max(maxY, y);\n      };\n      for (const r of regions) {\n        const b = r.bounds;\n        if (b instanceof Rectangle) scan([b.x + b.width], [b.y + b.height]);\n        else if (b instanceof Polygon) scan(b.xpoints, b.ypoints);\n        else if (b instanceof MultiPolygon) for (const p of b.polygons) scan(p.xpoints, p.ypoints);\n      }\n      w = Math.max(w, Math.ceil(maxX) + 2);\n      h = Math.max(h, Math.ceil(maxY) + 2);\n    }\n    return { w, h };\n  }\n}\n"]}

package/esm2022/lib/visualizer/region-load.mjs

@@ -0,0 +1,123 @@
+import { openHttpRegionSource } from '../region-source/http-region-source';
+import { REGION_SOURCE_MIN_CHARS } from '../region-source/region-source';
+import { openGeoJsonRegionSource } from '../region-source/worker-region-source';
+/** Per target, the latest {@link applyImageRois}: a stack source that opens after a later load is dropped. */
+const loads = new WeakMap();
+/**
+ * Apply an image's saved ROIs once its render has landed, choosing the region
+ * layout from the image's shape:
+ *
+ *  - **Folder stack** (`isStack && tiled === false`, see loadSeriesAsStack): a stack
+ *    of self-contained per-slice files. Each slice-file may carry its own sibling
+ *    `<stem>.geojson` (`roiJsonStrs[z]`), but a fresh folder with none yet leaves
+ *    `roiJsonStrs` undefined — so this keys off `tiled === false`, NOT `roiJsonStrs`,
+ *    and an unannotated folder stack still enters the per-slice-file layout (saving
+ *    back one geojson per slice-file) rather than the combined one (jit-ui#93).
+ *  - **Single-file z-stack**: one sibling geojson holding every slice's regions,
+ *    indexed by QuPath's `geometry.plane.z`. Per-slice (combined) mode is entered when
+ *    the geojson actually carries slice indices, or when there is nothing yet to
+ *    author against. A legacy geojson whose regions are all on the default plane
+ *    stays global (shown on every slice), so existing single-plane annotations are
+ *    not confined to slice 0.
+ *  - **Single plane** (or that legacy global stack): one region set for the image.
+ *    Loading saved ROIs is not a user edit, so the undo history starts fresh and the
+ *    first undo cannot wipe them (jit-ui#85).
+ *
+ * Large ROI files (`minSourceChars` and up) and a server-side source (`regionSourceUrl`)
+ * become tiled region sources instead of regions; a z-indexed one serves each slice its own
+ * plane. On a single-file stack the source is opened first, to tell which: one on the default
+ * plane only stays global, as its regions would. A folder stack's sources open lazily, the first
+ * time their slice is shown.
+ *
+ * `z` is the slice shown now; entering stack mode makes it live and resets undo. `http`, the
+ * host's `HttpClient`, carries a server-side source's requests, so the host's interceptors (its
+ * auth) apply to them as to the image tiles.
+ */
+export function applyImageRois(info, target, z, minSourceChars = REGION_SOURCE_MIN_CHARS, http) {
+    const attach = target.attachRegionSource?.bind(target);
+    const load = (loads.get(target) ?? 0) + 1;
+    loads.set(target, load);
+    const asSource = (json) => !!attach && !!json && json.length >= minSourceChars;
+    if (info.isStack && info.tiled === false) {
+        const perSlice = info.roiJsonStrs;
+        const sliceCount = info.urls?.length ?? perSlice?.length ?? 0;
+        const slices = new Map();
+        const sourced = [];
+        for (let s = 0; s < sliceCount; s++) {
+            const json = perSlice?.[s] ?? null;
+            if (asSource(json))
+                sourced.push(s);
+            slices.set(s, json && !asSource(json) ? target.importRegions(json) : []);
+        }
+        target.enterStackMode(slices, z, 'per-slice-file');
+        for (const s of sourced)
+            attach?.(() => openGeoJsonRegionSource(perSlice?.[s]), { slice: s });
+        return;
+    }
+    const roiJson = info.roiJsonStr;
+    if (attach && (info.regionSourceUrl || asSource(roiJson))) {
+        const url = info.regionSourceUrl;
+        const open = url
+            ? () => openHttpRegionSource(url, { http })
+            : () => openGeoJsonRegionSource(roiJson);
+        // As loading a file of regions replaces the regions, a source starts the image afresh.
+        target.setRegions([]);
+        target.resetUndoHistory();
+        if (!info.isStack) {
+            attach(open, { slice: 0 });
+            return;
+        }
+        // A stack: per slice when the source is z-indexed, else global (as its regions would be).
+        // The store learns the slice the image opened on (a host may open a stack on any slice), so
+        // the source, laid out on the store's slice once it opens, shows that one; a scrub meanwhile
+        // records its own, which then wins.
+        if (!target.isStackMode?.())
+            target.setDisplaySlice?.(z);
+        let first = open();
+        const reuse = () => {
+            const opening = first;
+            first = null;
+            return opening ?? open();
+        };
+        const lay = (zIndexed) => {
+            if (loads.get(target) !== load) {
+                void first?.then((source) => source.dispose(), () => undefined);
+                return;
+            }
+            if (zIndexed) {
+                target.enterStackMode(new Map(), target.getDisplaySlice?.() ?? z, 'combined');
+                attach(reuse, 'planes');
+            }
+            else {
+                attach(reuse, { slice: 0 });
+            }
+        };
+        // One that cannot be opened is attached as a single plane (its slice reports the failure).
+        first.then((source) => lay(source.info.planes.some((p) => p !== 0)), () => lay(false));
+        return;
+    }
+    if (info.isStack) {
+        const regions = roiJson ? target.importRegions(roiJson) : [];
+        if (!roiJson || regions.some((r) => (r.z ?? 0) !== 0)) {
+            target.enterStackMode(bySlice(regions), z, 'combined');
+            return;
+        }
+    }
+    if (roiJson)
+        target.setRegions(target.importRegions(roiJson));
+    target.resetUndoHistory();
+}
+/** Bucket regions by their zero-based {@link Region.z} (unset = slice 0). */
+function bySlice(regions) {
+    const slices = new Map();
+    for (const r of regions) {
+        const z = r.z ?? 0;
+        const bucket = slices.get(z);
+        if (bucket)
+            bucket.push(r);
+        else
+            slices.set(z, [r]);
+    }
+    return slices;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-load.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/region-load.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HttpClient } from '@angular/common/http';\nimport { IImageInfo } from '../contracts/image.contract';\nimport { IRegionStore } from '../contracts/visualizer.contract';\nimport { Region } from '../models/region';\nimport { openHttpRegionSource } from '../region-source/http-region-source';\nimport { REGION_SOURCE_MIN_CHARS, RegionSource } from '../region-source/region-source';\nimport { openGeoJsonRegionSource } from '../region-source/worker-region-source';\nimport type { RegionSourceOpener, RegionSourceSlices } from '../store/region-source-scope';\n\n/** The region-store members {@link applyImageRois} writes through. A target without\n *  `attachRegionSource` loads every ROI file as regions. */\nexport type RegionLoadTarget = Pick<\n  IRegionStore,\n  'importRegions' | 'enterStackMode' | 'setRegions' | 'resetUndoHistory'\n> & {\n  attachRegionSource?(source: RegionSource | RegionSourceOpener, slices?: RegionSourceSlices): void;\n  /** The slice shown now (what a stack's source, laid out once it opens, makes live). */\n  getDisplaySlice?(): number;\n  /** Record the slice shown (outside stack mode it only records it): see {@link applyImageRois}. */\n  setDisplaySlice?(z: number): void;\n  isStackMode?(): boolean;\n};\n\n/** Per target, the latest {@link applyImageRois}: a stack source that opens after a later load is dropped. */\nconst loads = new WeakMap<RegionLoadTarget, number>();\n\n/**\n * Apply an image's saved ROIs once its render has landed, choosing the region\n * layout from the image's shape:\n *\n *  - **Folder stack** (`isStack && tiled === false`, see loadSeriesAsStack): a stack\n *    of self-contained per-slice files. Each slice-file may carry its own sibling\n *    `<stem>.geojson` (`roiJsonStrs[z]`), but a fresh folder with none yet leaves\n *    `roiJsonStrs` undefined — so this keys off `tiled === false`, NOT `roiJsonStrs`,\n *    and an unannotated folder stack still enters the per-slice-file layout (saving\n *    back one geojson per slice-file) rather than the combined one (jit-ui#93).\n *  - **Single-file z-stack**: one sibling geojson holding every slice's regions,\n *    indexed by QuPath's `geometry.plane.z`. Per-slice (combined) mode is entered when\n *    the geojson actually carries slice indices, or when there is nothing yet to\n *    author against. A legacy geojson whose regions are all on the default plane\n *    stays global (shown on every slice), so existing single-plane annotations are\n *    not confined to slice 0.\n *  - **Single plane** (or that legacy global stack): one region set for the image.\n *    Loading saved ROIs is not a user edit, so the undo history starts fresh and the\n *    first undo cannot wipe them (jit-ui#85).\n *\n * Large ROI files (`minSourceChars` and up) and a server-side source (`regionSourceUrl`)\n * become tiled region sources instead of regions; a z-indexed one serves each slice its own\n * plane. On a single-file stack the source is opened first, to tell which: one on the default\n * plane only stays global, as its regions would. A folder stack's sources open lazily, the first\n * time their slice is shown.\n *\n * `z` is the slice shown now; entering stack mode makes it live and resets undo. `http`, the\n * host's `HttpClient`, carries a server-side source's requests, so the host's interceptors (its\n * auth) apply to them as to the image tiles.\n */\nexport function applyImageRois(\n  info: IImageInfo,\n  target: RegionLoadTarget,\n  z: number,\n  minSourceChars = REGION_SOURCE_MIN_CHARS,\n  http?: HttpClient,\n): void {\n  const attach = target.attachRegionSource?.bind(target);\n  const load = (loads.get(target) ?? 0) + 1;\n  loads.set(target, load);\n  const asSource = (json: string | null | undefined): json is string =>\n    !!attach && !!json && json.length >= minSourceChars;\n\n  if (info.isStack && info.tiled === false) {\n    const perSlice = info.roiJsonStrs;\n    const sliceCount = info.urls?.length ?? perSlice?.length ?? 0;\n    const slices = new Map<number, Region[]>();\n    const sourced: number[] = [];\n    for (let s = 0; s < sliceCount; s++) {\n      const json = perSlice?.[s] ?? null;\n      if (asSource(json)) sourced.push(s);\n      slices.set(s, json && !asSource(json) ? target.importRegions(json) : []);\n    }\n    target.enterStackMode(slices, z, 'per-slice-file');\n    for (const s of sourced) attach?.(() => openGeoJsonRegionSource(perSlice?.[s] as string), { slice: s });\n    return;\n  }\n\n  const roiJson = info.roiJsonStr;\n  if (attach && (info.regionSourceUrl || asSource(roiJson))) {\n    const url = info.regionSourceUrl;\n    const open: RegionSourceOpener = url\n      ? () => openHttpRegionSource(url, { http })\n      : () => openGeoJsonRegionSource(roiJson as string);\n    // As loading a file of regions replaces the regions, a source starts the image afresh.\n    target.setRegions([]);\n    target.resetUndoHistory();\n    if (!info.isStack) {\n      attach(open, { slice: 0 });\n      return;\n    }\n    // A stack: per slice when the source is z-indexed, else global (as its regions would be).\n    // The store learns the slice the image opened on (a host may open a stack on any slice), so\n    // the source, laid out on the store's slice once it opens, shows that one; a scrub meanwhile\n    // records its own, which then wins.\n    if (!target.isStackMode?.()) target.setDisplaySlice?.(z);\n    let first: Promise<RegionSource> | null = open();\n    const reuse: RegionSourceOpener = () => {\n      const opening = first;\n      first = null;\n      return opening ?? open();\n    };\n    const lay = (zIndexed: boolean) => {\n      if (loads.get(target) !== load) {\n        void first?.then(\n          (source) => source.dispose(),\n          () => undefined,\n        );\n        return;\n      }\n      if (zIndexed) {\n        target.enterStackMode(new Map(), target.getDisplaySlice?.() ?? z, 'combined');\n        attach(reuse, 'planes');\n      } else {\n        attach(reuse, { slice: 0 });\n      }\n    };\n    // One that cannot be opened is attached as a single plane (its slice reports the failure).\n    first.then(\n      (source) => lay(source.info.planes.some((p) => p !== 0)),\n      () => lay(false),\n    );\n    return;\n  }\n  if (info.isStack) {\n    const regions = roiJson ? target.importRegions(roiJson) : [];\n    if (!roiJson || regions.some((r) => (r.z ?? 0) !== 0)) {\n      target.enterStackMode(bySlice(regions), z, 'combined');\n      return;\n    }\n  }\n  if (roiJson) target.setRegions(target.importRegions(roiJson));\n  target.resetUndoHistory();\n}\n\n/** Bucket regions by their zero-based {@link Region.z} (unset = slice 0). */\nfunction bySlice(regions: Region[]): Map<number, Region[]> {\n  const slices = new Map<number, Region[]>();\n  for (const r of regions) {\n    const z = r.z ?? 0;\n    const bucket = slices.get(z);\n    if (bucket) bucket.push(r);\n    else slices.set(z, [r]);\n  }\n  return slices;\n}\n"]}

package/esm2022/lib/visualizer/spatial-dataset-binder.mjs

@@ -0,0 +1,163 @@
+import { takeUntil } from 'rxjs/operators';
+import { PlotType, isSpatialOmics3d } from '../contracts/plot-type';
+import { buildVolumeStackImage } from '../spatial/spatial-volume-image';
+/**
+ * Binds the viewer to the spatial-omics dataset on `SPATIAL_DATA_PORT`: the gates it
+ * puts on the plot-type selector ({@link gates}), the mode an image-less dataset opens
+ * on, and publishing a dataset's registered volume AS the image.
+ *
+ * No-op when the host provides no port — the spatial types then stay hidden.
+ */
+export class SpatialDatasetBinder {
+    constructor(port, host) {
+        this.port = port;
+        this.host = host;
+        /** The dataset on offer, for drawing one that brings no image. */
+        this.dataset = null;
+        /** A dataset is published — gates the spatial plot types; the toolbar binds it too. */
+        this.hasDataset = false;
+        /** Its observations carry a z, gating the 3D spatial mode. */
+        this.has3d = false;
+        /** It brings pixels of its own (see {@link SpatialGates.hasPixels}). */
+        this.hasPixels = false;
+        /** Dataset identity + capability shape the last emission was handled at, so a
+         *  switch between two datasets of the same shape is not mistaken for a repeat. */
+        this.key = null;
+        /** Dataset + geometry the published volume image was built from, so a re-emitted
+         *  dataset doesn't re-fetch megabytes or reset the user's scrub. */
+        this.volumeImageKey = null;
+        /** Blob URLs backing that image — ours to revoke. */
+        this.volumeImageUrls = [];
+    }
+    /** Follow the port's dataset until `until$` emits. */
+    bind(until$) {
+        this.port
+            ?.getDataset$()
+            .pipe(takeUntil(until$))
+            .subscribe((dataset) => this.onDataset(dataset ?? null));
+    }
+    /** Revoke the published volume image's blob URLs (teardown). */
+    dispose() {
+        this.revokeVolumeImageUrls();
+    }
+    onDataset(dataset) {
+        this.dataset = dataset;
+        // Only a dataset whose observations carry a z can be drawn as a cloud, so the 3D
+        // mode is gated on the coordinates, not merely on a dataset being present.
+        const has3d = !!dataset?.observations.z;
+        const hasVolume = !!dataset?.volume;
+        // The port publishes its current value on subscribe, so the initial `null` would
+        // otherwise recompute the selector for no change. Keyed by dataset IDENTITY as well
+        // as capability shape: two 3D datasets that both carry a volume have the same
+        // shape, and comparing only that skipped the switch — leaving the previous
+        // dataset's volume image on screen underneath the new one's observations.
+        const key = dataset
+            ? `${dataset.id}|${has3d}|${hasVolume}|${dataset.volume ? `${dataset.volume.width}x${dataset.volume.height}x${dataset.volume.depth}` : ''}`
+            : null;
+        if (key === this.key)
+            return;
+        this.key = key;
+        this.hasDataset = !!dataset;
+        this.has3d = has3d;
+        // Whether the dataset brings pixels: it registers onto a tissue image (which may
+        // still be on its way — the pixel modes must not flicker out while it arrives), or
+        // its volume is published AS a grayscale z-stack image. Either way the pixel modes
+        // stay on offer — Volume and Isosurface are exactly how a 3D omics dataset is read.
+        this.hasPixels = !!dataset?.imageRef || hasVolume;
+        this.host.gatesChanged();
+        if (dataset && !dataset.imageRef && hasVolume) {
+            // No section to draw observations over (a cloud registered into a common frame,
+            // the Allen CCF), but a registered VOLUME: make that the image and open on it,
+            // slice bar and all. Ordered after the gates so the type is on offer first.
+            void this.showVolumeAsImage(dataset);
+        }
+        else {
+            // Anything else means a published volume image is no longer what is on screen.
+            // Forget it, or coming BACK to the volume dataset would short-circuit on a
+            // matching key and leave the other dataset's slide up.
+            this.dropVolumeImage();
+            if (dataset && !dataset.imageRef) {
+                // No reference image and no volume: the observations are all there is, so open
+                // on whichever spatial mode their coordinates support — leaving the type alone
+                // strands the host on the previous slide. A one-plane assay has no z and
+                // cannot be a cloud.
+                const target = has3d ? PlotType.SPATIAL_OMICS_3D : PlotType.SPATIAL_OMICS;
+                if (this.host.selectedId() !== target)
+                    this.host.selectPlotType(target);
+                // Same mode, another image-less dataset, nothing loaded: re-plot so its
+                // placeholder image info (and with it the regions' key) is this dataset's.
+                else if (!this.host.hasImage())
+                    this.host.replot();
+            }
+        }
+        // Clearing the dataset while a spatial mode is active leaves a type that is no
+        // longer offered — the host falls back, as turning test mode off does.
+        this.host.settled();
+    }
+    /**
+     * Publish a dataset's reference volume AS the image, and open the 2D Image view on it:
+     * the slice bar scrubs z, and the contrast window, colormaps and region tools all work
+     * because the volume genuinely is the image now. The 3D cloud stays one pick away.
+     *
+     * Keyed by dataset + geometry: the dataset stream re-emits on things like a
+     * colour-column change, and rebuilding then would re-fetch the voxels and throw the
+     * user back to the middle slice.
+     */
+    async showVolumeAsImage(dataset) {
+        const meta = dataset.volume;
+        if (!meta || !this.port?.getVolume)
+            return;
+        const key = `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}`;
+        if (key === this.volumeImageKey)
+            return;
+        // Claim the key BEFORE awaiting: the stream can emit again while the voxels are in
+        // flight, and two builds of the same volume would race to publish.
+        this.volumeImageKey = key;
+        this.host.setImageLoading(true);
+        try {
+            const built = await buildVolumeStackImage(dataset, await this.port.getVolume());
+            // A different dataset was selected while this one encoded: drop what we built.
+            if (this.volumeImageKey !== key) {
+                built?.urls.forEach((u) => URL.revokeObjectURL(u));
+                return;
+            }
+            if (!built) {
+                this.volumeImageKey = null;
+                return;
+            }
+            // Pick the mode first so the image lands in the view that will show it.
+            if (this.host.selectedId() !== PlotType.IMAGE)
+                this.host.selectPlotType(PlotType.IMAGE);
+            this.revokeVolumeImageUrls();
+            this.volumeImageUrls = built.urls;
+            this.host.publishImage(built.info);
+        }
+        catch (err) {
+            // No volume served after all: the cloud is still renderable, so fall back to it.
+            console.warn('[visualizer] reference volume unavailable — falling back to the 3D cloud', err);
+            this.volumeImageKey = null;
+            if (this.has3d && !isSpatialOmics3d(this.host.basePlotType())) {
+                this.host.selectPlotType(PlotType.SPATIAL_OMICS_3D);
+            }
+        }
+        finally {
+            // Only the build still on screen (or one that failed and released its key) may
+            // drop the overlay: a newer volume build that superseded this one is still encoding.
+            if (this.volumeImageKey === key || this.volumeImageKey === null)
+                this.host.setImageLoading(false);
+            this.host.detectChanges();
+        }
+    }
+    /** Forget the published volume image so re-selecting the dataset rebuilds it. The
+     *  URLs deliberately stay alive: the host may still be displaying that image, and
+     *  revoking under it would break every later tile read. They are freed when the next
+     *  volume replaces them, or on {@link dispose}. */
+    dropVolumeImage() {
+        this.volumeImageKey = null;
+    }
+    revokeVolumeImageUrls() {
+        this.volumeImageUrls.forEach((u) => URL.revokeObjectURL(u));
+        this.volumeImageUrls = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-dataset-binder.js","sourceRoot":"","sources":["../../../../src/lib/visualizer/spatial-dataset-binder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { IImageInfo } from '../contracts/image.contract';\nimport { PlotType, PlotTypeId, isSpatialOmics3d } from '../contracts/plot-type';\nimport { SpatialDataPort } from '../contracts/ports/spatial-data.port';\nimport { SpatialDataset } from '../contracts/spatial-dataset.contract';\nimport { SpatialGates } from '../plot-mode/plot-type-menu';\nimport { buildVolumeStackImage } from '../spatial/spatial-volume-image';\n\n/** What a dataset switch asks of the viewer. */\nexport interface SpatialBinderHost {\n  /** The plot-type gates changed: recompute the selector. */\n  gatesChanged(): void;\n  /** The selector's current id, and the built-in type rendered for it. */\n  selectedId(): PlotTypeId;\n  basePlotType(): PlotType;\n  /** Whether an image is loaded. */\n  hasImage(): boolean;\n  selectPlotType(type: PlotType): void;\n  /** Re-plot the current mode. */\n  replot(): void;\n  /** Publish an image as the host's current one. */\n  publishImage(info: IImageInfo): void;\n  setImageLoading(loading: boolean): void;\n  /** The switch is handled: reconcile the selection with the new gates and re-render. */\n  settled(): void;\n  detectChanges(): void;\n}\n\n/**\n * Binds the viewer to the spatial-omics dataset on `SPATIAL_DATA_PORT`: the gates it\n * puts on the plot-type selector ({@link gates}), the mode an image-less dataset opens\n * on, and publishing a dataset's registered volume AS the image.\n *\n * No-op when the host provides no port — the spatial types then stay hidden.\n */\nexport class SpatialDatasetBinder implements SpatialGates {\n  /** The dataset on offer, for drawing one that brings no image. */\n  dataset: SpatialDataset | null = null;\n  /** A dataset is published — gates the spatial plot types; the toolbar binds it too. */\n  hasDataset = false;\n  /** Its observations carry a z, gating the 3D spatial mode. */\n  has3d = false;\n  /** It brings pixels of its own (see {@link SpatialGates.hasPixels}). */\n  hasPixels = false;\n  /** Dataset identity + capability shape the last emission was handled at, so a\n   *  switch between two datasets of the same shape is not mistaken for a repeat. */\n  private key: string | null = null;\n  /** Dataset + geometry the published volume image was built from, so a re-emitted\n   *  dataset doesn't re-fetch megabytes or reset the user's scrub. */\n  private volumeImageKey: string | null = null;\n  /** Blob URLs backing that image — ours to revoke. */\n  private volumeImageUrls: string[] = [];\n\n  constructor(\n    private readonly port: SpatialDataPort | undefined,\n    private readonly host: SpatialBinderHost,\n  ) {}\n\n  /** Follow the port's dataset until `until$` emits. */\n  bind(until$: Observable<unknown>): void {\n    this.port\n      ?.getDataset$()\n      .pipe(takeUntil(until$))\n      .subscribe((dataset) => this.onDataset(dataset ?? null));\n  }\n\n  /** Revoke the published volume image's blob URLs (teardown). */\n  dispose(): void {\n    this.revokeVolumeImageUrls();\n  }\n\n  private onDataset(dataset: SpatialDataset | null): void {\n    this.dataset = dataset;\n    // Only a dataset whose observations carry a z can be drawn as a cloud, so the 3D\n    // mode is gated on the coordinates, not merely on a dataset being present.\n    const has3d = !!dataset?.observations.z;\n    const hasVolume = !!dataset?.volume;\n    // The port publishes its current value on subscribe, so the initial `null` would\n    // otherwise recompute the selector for no change. Keyed by dataset IDENTITY as well\n    // as capability shape: two 3D datasets that both carry a volume have the same\n    // shape, and comparing only that skipped the switch — leaving the previous\n    // dataset's volume image on screen underneath the new one's observations.\n    const key = dataset\n      ? `${dataset.id}|${has3d}|${hasVolume}|${\n          dataset.volume ? `${dataset.volume.width}x${dataset.volume.height}x${dataset.volume.depth}` : ''\n        }`\n      : null;\n    if (key === this.key) return;\n    this.key = key;\n    this.hasDataset = !!dataset;\n    this.has3d = has3d;\n    // Whether the dataset brings pixels: it registers onto a tissue image (which may\n    // still be on its way — the pixel modes must not flicker out while it arrives), or\n    // its volume is published AS a grayscale z-stack image. Either way the pixel modes\n    // stay on offer — Volume and Isosurface are exactly how a 3D omics dataset is read.\n    this.hasPixels = !!dataset?.imageRef || hasVolume;\n    this.host.gatesChanged();\n    if (dataset && !dataset.imageRef && hasVolume) {\n      // No section to draw observations over (a cloud registered into a common frame,\n      // the Allen CCF), but a registered VOLUME: make that the image and open on it,\n      // slice bar and all. Ordered after the gates so the type is on offer first.\n      void this.showVolumeAsImage(dataset);\n    } else {\n      // Anything else means a published volume image is no longer what is on screen.\n      // Forget it, or coming BACK to the volume dataset would short-circuit on a\n      // matching key and leave the other dataset's slide up.\n      this.dropVolumeImage();\n      if (dataset && !dataset.imageRef) {\n        // No reference image and no volume: the observations are all there is, so open\n        // on whichever spatial mode their coordinates support — leaving the type alone\n        // strands the host on the previous slide. A one-plane assay has no z and\n        // cannot be a cloud.\n        const target = has3d ? PlotType.SPATIAL_OMICS_3D : PlotType.SPATIAL_OMICS;\n        if (this.host.selectedId() !== target) this.host.selectPlotType(target);\n        // Same mode, another image-less dataset, nothing loaded: re-plot so its\n        // placeholder image info (and with it the regions' key) is this dataset's.\n        else if (!this.host.hasImage()) this.host.replot();\n      }\n    }\n    // Clearing the dataset while a spatial mode is active leaves a type that is no\n    // longer offered — the host falls back, as turning test mode off does.\n    this.host.settled();\n  }\n\n  /**\n   * Publish a dataset's reference volume AS the image, and open the 2D Image view on it:\n   * the slice bar scrubs z, and the contrast window, colormaps and region tools all work\n   * because the volume genuinely is the image now. The 3D cloud stays one pick away.\n   *\n   * Keyed by dataset + geometry: the dataset stream re-emits on things like a\n   * colour-column change, and rebuilding then would re-fetch the voxels and throw the\n   * user back to the middle slice.\n   */\n  private async showVolumeAsImage(dataset: SpatialDataset): Promise<void> {\n    const meta = dataset.volume;\n    if (!meta || !this.port?.getVolume) return;\n    const key = `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}`;\n    if (key === this.volumeImageKey) return;\n    // Claim the key BEFORE awaiting: the stream can emit again while the voxels are in\n    // flight, and two builds of the same volume would race to publish.\n    this.volumeImageKey = key;\n    this.host.setImageLoading(true);\n    try {\n      const built = await buildVolumeStackImage(dataset, await this.port.getVolume());\n      // A different dataset was selected while this one encoded: drop what we built.\n      if (this.volumeImageKey !== key) {\n        built?.urls.forEach((u) => URL.revokeObjectURL(u));\n        return;\n      }\n      if (!built) {\n        this.volumeImageKey = null;\n        return;\n      }\n      // Pick the mode first so the image lands in the view that will show it.\n      if (this.host.selectedId() !== PlotType.IMAGE) this.host.selectPlotType(PlotType.IMAGE);\n      this.revokeVolumeImageUrls();\n      this.volumeImageUrls = built.urls;\n      this.host.publishImage(built.info);\n    } catch (err) {\n      // No volume served after all: the cloud is still renderable, so fall back to it.\n      console.warn('[visualizer] reference volume unavailable — falling back to the 3D cloud', err);\n      this.volumeImageKey = null;\n      if (this.has3d && !isSpatialOmics3d(this.host.basePlotType())) {\n        this.host.selectPlotType(PlotType.SPATIAL_OMICS_3D);\n      }\n    } finally {\n      // Only the build still on screen (or one that failed and released its key) may\n      // drop the overlay: a newer volume build that superseded this one is still encoding.\n      if (this.volumeImageKey === key || this.volumeImageKey === null) this.host.setImageLoading(false);\n      this.host.detectChanges();\n    }\n  }\n\n  /** Forget the published volume image so re-selecting the dataset rebuilds it. The\n   *  URLs deliberately stay alive: the host may still be displaying that image, and\n   *  revoking under it would break every later tile read. They are freed when the next\n   *  volume replaces them, or on {@link dispose}. */\n  private dropVolumeImage(): void {\n    this.volumeImageKey = null;\n  }\n\n  private revokeVolumeImageUrls(): void {\n    this.volumeImageUrls.forEach((u) => URL.revokeObjectURL(u));\n    this.volumeImageUrls = [];\n  }\n}\n"]}