@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.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,60 @@
+/**
+ * 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).
+ *
+ * `z` is the slice shown now; entering stack mode makes it live and resets undo.
+ */
+export function applyImageRois(info, target, z) {
+    if (info.isStack && info.tiled === false) {
+        const perSlice = info.roiJsonStrs;
+        const sliceCount = info.urls?.length ?? perSlice?.length ?? 0;
+        const slices = new Map();
+        for (let s = 0; s < sliceCount; s++) {
+            const json = perSlice?.[s] ?? null;
+            slices.set(s, json ? target.importRegions(json) : []);
+        }
+        target.enterStackMode(slices, z, 'per-slice-file');
+        return;
+    }
+    const roiJson = info.roiJsonStr;
+    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,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

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"]}