@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/implementations/osd/slice-cache.mjs

@@ -0,0 +1,488 @@
+import { OSD } from './osd-lib';
+export class SliceCache {
+    constructor(host) {
+        this.host = host;
+        /** z-slice → its TiledImage in the viewer world (composite path). */
+        this.sliceItems = new Map();
+        /** Multichannel per-slice cache: z → the N channel TiledImages for that slice
+         *  (additively composited by OSD; index = channel). Only the active slice's
+         *  visible channels have opacity > 0. */
+        this.channelSliceItems = new Map();
+        /** Cached multichannel slices whose tiles were tinted before the latest
+         *  display change; re-tinted lazily when next revealed by z-scrub. */
+        this.staleSlices = new Set();
+        /** Most-recently-shown z last; drives LRU eviction. */
+        this.sliceLru = [];
+        /** z-slices whose tiled image is being added (dedupe rapid scrubbing). */
+        this.slicesLoading = new Set();
+        /** Bumped whenever the loaded image changes; in-flight background slice adds
+         *  captured under an older token are dropped (cancelled image switch). */
+        this.sliceLoadToken = 0;
+        /** The slice the background loader is currently waiting on (its tiles are
+         *  still streaming): addTiledImage 'success' fires on add, not on tile load,
+         *  so we gate the next slice on getFullyLoaded(). */
+        this.bgLoadingZ = null;
+        /** When bgLoadingZ started loading — a fallback so a slow/stuck slice can't
+         *  stall the whole background pass forever. */
+        this.bgLoadingSince = 0;
+        /** Slices the background loader has already attempted (no tight retry loop). */
+        this.bgAttempted = new Set();
+        /** Max cached slice tiled images kept resident before LRU eviction. */
+        this.maxCachedSlices = 8;
+        /** Upper bound on resident slices, regardless of stack depth (memory guard). */
+        this.MAX_CACHED_SLICES_CAP = 64;
+        /** Fit-view tile budget above which background preloading is skipped: a huge
+         *  no-pyramid stack would preload every slice at full resolution and
+         *  flood/timeout. Normal stacks stay below it and KEEP the flicker-free
+         *  pre-cache. */
+        this.MAX_PREFETCH_FIT_TILES = 256;
+        /** True only for stacks too large to background-preload. */
+        this.skipSlicePrefetch = false;
+        this.prefetchTimer = null;
+    }
+    // ── configuration (per image, from plot()) ────────────────────────────
+    /** Size the cache for the loaded image: keep the whole stack resident
+     *  (capped) so the background loader fills every slice without evicting
+     *  itself; skip preloading entirely when even the coarsest level's tile
+     *  grid is too large (its slices only exist at full resolution). */
+    configure(stackDepth, coarseFitTiles) {
+        this.skipSlicePrefetch = coarseFitTiles > this.MAX_PREFETCH_FIT_TILES;
+        this.maxCachedSlices =
+            stackDepth > 1 ? Math.min(this.MAX_CACHED_SLICES_CAP, stackDepth) : 1;
+    }
+    /** Current LRU cap (the viewer sizes its tile cache from it). */
+    maxSlices() {
+        return this.maxCachedSlices;
+    }
+    /** Drop the per-channel groups (on a fresh plot). */
+    clearChannelGroups() {
+        this.channelSliceItems.clear();
+    }
+    /** Seed the cache with the just-opened composite slice (world item 0), so
+     *  scrubbing back to it later is an instant opacity toggle, not a re-open. */
+    seedComposite(z, item) {
+        this.sliceItems.set(z, item);
+        this.touchSliceLru(z);
+    }
+    // ── slice display (setZIndex's cache work) ────────────────────────────
+    /** Show slice z: reveal it instantly when cached (re-tinting a stale
+     *  multichannel group), otherwise add it once. The current slice stays
+     *  visible until the new one is in — no white-flicker. */
+    showSlice(z) {
+        if (this.host.isMultiChannel()) {
+            const group = this.channelSliceItems.get(z);
+            if (group && group.length && group.some((it) => it && this.sliceInWorld(it))) {
+                this.revealChannelSlice(z);
+                // If a display change happened while this slice was cached, its tiles
+                // hold a stale tint — re-apply now (it's the visible slice, so the
+                // brief restore flash is acceptable, like a fresh load).
+                if (this.staleSlices.delete(z))
+                    this.invalidateSlice(z);
+                this.touchSliceLru(z);
+                this.schedulePrefetch();
+            }
+            else if (!this.slicesLoading.has(z)) {
+                this.addChannelSlice(z);
+            }
+            return;
+        }
+        const cached = this.sliceItems.get(z);
+        if (cached && this.sliceInWorld(cached)) {
+            // Instant: reveal the cached slice, hide the others — no fetch/decode.
+            this.showOnlySlice(z);
+            this.touchSliceLru(z);
+            this.schedulePrefetch();
+            return;
+        }
+        if (this.slicesLoading.has(z))
+            return; // already being added; success reveals it
+        this.addSlice(z);
+    }
+    /** Add a never-seen slice as a hidden tiled image, then reveal it once loaded
+     *  (composite path; multichannel routes to addChannelSlice). */
+    addSlice(z) {
+        if (!this.host.hasImage())
+            return;
+        if (this.host.isMultiChannel()) {
+            this.addChannelSlice(z);
+            return;
+        }
+        this.slicesLoading.add(z);
+        // Tag this add to the current image; if the user switches images before it
+        // resolves, the stale callback is dropped (the add belongs to the old stack).
+        const token = this.sliceLoadToken;
+        const ts = this.host.buildTileSource(z);
+        try {
+            // addTiledImage lives on the Viewer (it queues the add into the world).
+            this.host.viewer().addTiledImage({
+                tileSource: ts,
+                x: 0,
+                y: 0,
+                width: 1, // match the primary image's normalized placement
+                opacity: 0,
+                // Load tiles even though it's hidden — this is what lets the background
+                // loader fill every slice's cache so scrubbing gets progressively smoother.
+                preload: true,
+                success: (e) => {
+                    const item = e?.item;
+                    if (token !== this.sliceLoadToken) {
+                        // Image switched while this was adding — drop the orphan so it stops
+                        // loading instead of streaming tiles for the abandoned stack.
+                        if (item) {
+                            try {
+                                this.host.viewer()?.world?.removeItem(item);
+                            }
+                            catch { /* gone */ }
+                        }
+                        return;
+                    }
+                    this.slicesLoading.delete(z);
+                    if (!item)
+                        return;
+                    this.sliceItems.set(z, item);
+                    this.touchSliceLru(z);
+                    this.host.onCompositeSliceAdded(z);
+                    // Only reveal if the user is still on this slice (fast scrubbing may
+                    // have moved on — leave it cached/hidden for a later revisit).
+                    if (z === this.host.currentZ()) {
+                        this.showOnlySlice(z);
+                        this.schedulePrefetch();
+                    }
+                    this.evictSliceLru();
+                },
+                error: () => {
+                    if (token === this.sliceLoadToken)
+                        this.slicesLoading.delete(z);
+                },
+            });
+        }
+        catch (err) {
+            this.slicesLoading.delete(z);
+            console.warn('[OSD] failed to add z-slice', err);
+        }
+    }
+    /**
+     * Add slice z's channel group: one additively-composited ('lighter' = Fiji
+     * "Composite") TiledImage per channel, hidden (opacity 0) until revealed.
+     * Each is preloaded so the background loader can pre-fill every slice.
+     * Cached so a revisit is an instant opacity toggle — no re-fetch, no
+     * white-flicker. Mirrors addSlice for the composite path.
+     */
+    addChannelSlice(z) {
+        if (!this.host.hasImage())
+            return;
+        if (this.channelSliceItems.has(z) || this.slicesLoading.has(z))
+            return;
+        this.slicesLoading.add(z);
+        const token = this.sliceLoadToken;
+        const n = this.host.channelCount();
+        const group = new Array(n);
+        let settled = 0;
+        const onSettled = () => {
+            if (++settled < n)
+                return;
+            if (token !== this.sliceLoadToken)
+                return; // image switched mid-add
+            this.slicesLoading.delete(z);
+            this.channelSliceItems.set(z, group);
+            this.staleSlices.delete(z); // freshly tinted at the current display state
+            this.touchSliceLru(z);
+            if (z === this.host.currentZ()) {
+                this.revealChannelSlice(z); // tiles may still be decoding; opacity is set now
+                this.schedulePrefetch();
+            }
+            this.evictSliceLru();
+        };
+        for (let c = 0; c < n; c++) {
+            try {
+                this.host.viewer().addTiledImage({
+                    tileSource: this.host.buildTileSource(z, c),
+                    x: 0, y: 0, width: 1,
+                    opacity: 0, // revealed by revealChannelSlice once the group is in
+                    compositeOperation: 'lighter',
+                    preload: true,
+                    success: (e) => {
+                        const item = e?.item;
+                        if (token !== this.sliceLoadToken) {
+                            if (item) {
+                                try {
+                                    this.host.viewer()?.world?.removeItem(item);
+                                }
+                                catch { /* gone */ }
+                            }
+                            return;
+                        }
+                        if (item)
+                            group[c] = item;
+                        onSettled();
+                    },
+                    error: () => onSettled(),
+                });
+            }
+            catch (err) {
+                console.warn('[OSD] failed to add channel slice image', z, c, err);
+                onSettled();
+            }
+        }
+    }
+    /** Reveal slice z's channel group (each visible channel → opacity 1) and
+     *  hide every other cached slice's group. Instant; no fetch/decode. */
+    revealChannelSlice(z) {
+        for (const [zz, group] of this.channelSliceItems) {
+            const active = zz === z;
+            group.forEach((it, c) => {
+                if (!it)
+                    return;
+                const visible = this.host.channelVisible(c);
+                try {
+                    it.setOpacity(active && visible ? 1 : 0);
+                }
+                catch { /* gone */ }
+            });
+        }
+    }
+    /** Show the given composite slice (opacity 1) and hide all other cached slices. */
+    showOnlySlice(z) {
+        for (const [zz, item] of this.sliceItems) {
+            try {
+                item.setOpacity(zz === z ? 1 : 0);
+            }
+            catch { /* item gone */ }
+        }
+    }
+    // ── display invalidation (multichannel) ───────────────────────────────
+    /** Re-tint after a display change: invalidate ONLY the visible slice's
+     *  channel images — invalidating the whole world would re-process every
+     *  hidden/preloaded slice's tiles (hundreds), flooding OSD and wasting work
+     *  on tiles that aren't on screen. The other cached slices are marked stale
+     *  and re-tinted lazily when revealed. */
+    invalidateChannelDisplay(z) {
+        this.invalidateSlice(z);
+        this.staleSlices.clear();
+        for (const zz of this.channelSliceItems.keys()) {
+            if (zz !== z)
+                this.staleSlices.add(zz);
+        }
+    }
+    /** Invalidate (restore + re-recolor) just the channel images of one cached
+     *  slice. A shared timestamp batches the per-image invalidations into one
+     *  processing pass (OSD dedupes tiles already stamped at >= tStamp). */
+    invalidateSlice(z) {
+        const group = this.channelSliceItems.get(z) ?? [];
+        if (!group.length)
+            return;
+        const osd = OSD;
+        const tStamp = typeof osd.now === 'function' ? osd.now() : Date.now();
+        for (const it of group) {
+            if (it && typeof it.requestInvalidate === 'function') {
+                try {
+                    it.requestInvalidate(true, false, tStamp);
+                }
+                catch { /* gone */ }
+            }
+        }
+    }
+    // ── background stack preloading ───────────────────────────────────────
+    /** Debounce so a burst of viewport/slice events coalesces, then advance the
+     *  background stack loader by one slice. */
+    schedulePrefetch() {
+        if (this.skipSlicePrefetch)
+            return;
+        if (this.prefetchTimer)
+            clearTimeout(this.prefetchTimer);
+        this.prefetchTimer = setTimeout(() => this.loadNextBackgroundSlice(), 200);
+    }
+    /**
+     * Background-load the whole stack: add each not-yet-cached slice as a
+     * hidden, preloaded tiled image, one at a time, working outward from the
+     * current slice — and never blocking the visible slice (it yields while the
+     * current view is still streaming tiles; only one slice is in flight at a
+     * time so the on-screen tiles always win the connection).
+     */
+    loadNextBackgroundSlice() {
+        this.prefetchTimer = null;
+        if (!this.host.hasImage())
+            return;
+        const sliceCount = this.host.sliceCount();
+        if (sliceCount <= 1)
+            return; // not a stack — nothing to preload
+        // Yield to the visible slice while it's still streaming tiles.
+        if (this.sliceTilesLoading(this.host.currentZ())) {
+            this.schedulePrefetch();
+            return;
+        }
+        // Gate on the in-flight slice's TILES finishing — addTiledImage's success
+        // fires on add, not on tile load, so without this we'd add the whole stack
+        // at once and flood the connection. A time fallback prevents a stuck slice
+        // from stalling the pass.
+        if (this.bgLoadingZ != null) {
+            const adding = this.slicesLoading.has(this.bgLoadingZ);
+            const tilesLoading = this.sliceTilesLoading(this.bgLoadingZ);
+            const timedOut = Date.now() - this.bgLoadingSince > 8000;
+            if ((adding || tilesLoading) && !timedOut) {
+                this.schedulePrefetch();
+                return;
+            }
+            this.bgLoadingZ = null; // that slice's tiles are in (or gave up) — advance
+        }
+        const next = this.nearestUncachedSlice(sliceCount);
+        if (next == null)
+            return; // whole stack cached — done
+        this.bgLoadingZ = next;
+        this.bgLoadingSince = Date.now();
+        this.bgAttempted.add(next);
+        this.addSlice(next); // hidden + preload (added with opacity 0; not revealed)
+        this.schedulePrefetch(); // poll until its tiles load, then advance
+    }
+    /** The not-yet-cached slice closest to the current one (load nearest first),
+     *  skipping any already attempted so a failed/slow one isn't retried in a loop. */
+    nearestUncachedSlice(sliceCount) {
+        const cur = this.host.currentZ();
+        for (let d = 0; d < sliceCount; d++) {
+            const candidates = d === 0 ? [cur] : [cur - d, cur + d];
+            for (const z of candidates) {
+                if (z >= 0 && z < sliceCount &&
+                    !this.sliceCacheHas(z) && !this.slicesLoading.has(z) && !this.bgAttempted.has(z)) {
+                    return z;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Stop background stack preloading and invalidate any in-flight slice add.
+     * Called when a different image is selected so the previous stack stops
+     * loading immediately instead of finishing in the background.
+     */
+    cancelBackgroundLoad() {
+        if (this.prefetchTimer) {
+            clearTimeout(this.prefetchTimer);
+            this.prefetchTimer = null;
+        }
+        this.slicesLoading.clear();
+        this.bgLoadingZ = null;
+        this.bgAttempted.clear();
+        this.sliceLoadToken++; // drop pending addTiledImage callbacks from the old image
+        // Abort in-flight background tiles immediately by dropping the hidden
+        // preloaded slices (removeItem cancels their pending tile loads). Keep the
+        // visible slice so the current view doesn't blank before the next plot.
+        this.dropHiddenSlices();
+    }
+    /** Remove every cached slice except the currently displayed one, aborting
+     *  their in-flight tile requests. */
+    dropHiddenSlices() {
+        const v = this.host.viewer();
+        if (!v)
+            return;
+        const cur = this.host.currentZ();
+        for (const [z, item] of [...this.sliceItems]) {
+            if (z === cur)
+                continue;
+            this.sliceItems.delete(z);
+            try {
+                v.world.removeItem(item);
+            }
+            catch { /* already gone */ }
+        }
+        for (const [z, group] of [...this.channelSliceItems]) {
+            if (z === cur)
+                continue;
+            this.channelSliceItems.delete(z);
+            for (const it of group) {
+                if (it) {
+                    try {
+                        v.world.removeItem(it);
+                    }
+                    catch { /* gone */ }
+                }
+            }
+        }
+        this.sliceLru = this.sliceCacheHas(cur) ? [cur] : [];
+    }
+    // ── cache bookkeeping ─────────────────────────────────────────────────
+    /** Whether slice z is in the active cache (composite single image, or the
+     *  multichannel per-channel group). */
+    sliceCacheHas(z) {
+        return this.host.isMultiChannel() ? this.channelSliceItems.has(z) : this.sliceItems.has(z);
+    }
+    /** The cached TiledImage(s) for slice z (0–1 for composite, N for multichannel). */
+    sliceGroup(z) {
+        if (this.host.isMultiChannel())
+            return this.channelSliceItems.get(z) ?? [];
+        const it = this.sliceItems.get(z);
+        return it ? [it] : [];
+    }
+    /** Whether slice z's tiles are still streaming (any cached image not fully loaded). */
+    sliceTilesLoading(z) {
+        const g = this.sliceGroup(z);
+        if (!g.length)
+            return false;
+        return g.some((it) => it && typeof it.getFullyLoaded === 'function' && !it.getFullyLoaded());
+    }
+    /** Remove slice z's cached image(s) from the world and the active cache. */
+    removeCachedSlice(z) {
+        const v = this.host.viewer();
+        if (this.host.isMultiChannel()) {
+            const group = this.channelSliceItems.get(z);
+            this.channelSliceItems.delete(z);
+            if (group && v)
+                for (const it of group) {
+                    if (it) {
+                        try {
+                            v.world.removeItem(it);
+                        }
+                        catch { /* gone */ }
+                    }
+                }
+        }
+        else {
+            const item = this.sliceItems.get(z);
+            this.sliceItems.delete(z);
+            if (item && v) {
+                try {
+                    v.world.removeItem(item);
+                }
+                catch { /* gone */ }
+            }
+        }
+    }
+    /** Is the tiled image still in the world (not evicted)? */
+    sliceInWorld(item) {
+        try {
+            return this.host.viewer().world.getIndexOfItem(item) >= 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Mark z as most-recently-used. */
+    touchSliceLru(z) {
+        const i = this.sliceLru.indexOf(z);
+        if (i >= 0)
+            this.sliceLru.splice(i, 1);
+        this.sliceLru.push(z);
+    }
+    /** Drop the least-recently-used cached slices beyond the cap (never the
+     *  current one), removing their tiled images so memory stays bounded. */
+    evictSliceLru() {
+        while (this.sliceLru.length > this.maxCachedSlices) {
+            const cur = this.host.currentZ();
+            const idx = this.sliceLru.findIndex((z) => z !== cur);
+            if (idx < 0)
+                break;
+            const z = this.sliceLru.splice(idx, 1)[0];
+            this.removeCachedSlice(z);
+        }
+    }
+    /** Clear the cache (on teardown / image switch). */
+    reset() {
+        this.sliceItems.clear();
+        this.channelSliceItems.clear();
+        this.staleSlices.clear();
+        this.sliceLru = [];
+        this.slicesLoading.clear();
+        this.bgLoadingZ = null;
+        this.bgAttempted.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slice-cache.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/slice-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { OSD } from './osd-lib';\n\n/**\n * Stack-slice cache for the OpenSeadragon backend (refactoring plan, Step 3 —\n * a pure move of the cache cluster out of the visualizer service).\n *\n * Scrubbing the z-slider used to viewer.open() a fresh tile source per slice,\n * which destroys the current tiled image (and its decoded+recolored tiles), so\n * revisiting a slice re-fetched everything. Instead we keep each visited slice\n * as its own tiled image in the world and just toggle opacity — a revisited\n * slice is instant (no network, no re-decode, no re-recolor). Bounded by an\n * LRU so deep stacks don't grow without limit. Multichannel slices cache one\n * TiledImage per channel (additively composited); composite slices cache one.\n * A background loader pre-fills the rest of the stack, one slice at a time,\n * yielding to the visible slice so on-screen tiles always win the connection.\n */\n\n/** What the cache needs from the visualizer service. All accessors are live\n *  (called at use time, never captured) so the cache always sees the current\n *  viewer/descriptor/z — matching the field reads it replaced. */\nexport interface SliceCacheHost {\n  /** The mounted viewer, or null. */\n  viewer(): any | null;\n  /** True when a viewer, descriptor and infoB64 are all present. */\n  hasImage(): boolean;\n  /** Stack depth (descriptor.z, 1 for single images). */\n  sliceCount(): number;\n  /** The currently displayed z-slice. */\n  currentZ(): number;\n  /** Per-channel rendering (multichannel fluorescence) vs composite. */\n  isMultiChannel(): boolean;\n  /** Channel count for a multichannel group add. */\n  channelCount(): number;\n  /** Channel visibility (drives group reveal opacity). */\n  channelVisible(c: number): boolean;\n  /** Tile source for slice z (optionally one channel). */\n  buildTileSource(z: number, channel?: number): any;\n  /** A composite slice landed in the world — the service samples its window. */\n  onCompositeSliceAdded(z: number): void;\n}\n\nexport class SliceCache {\n  /** z-slice → its TiledImage in the viewer world (composite path). */\n  private sliceItems = new Map<number, any>();\n  /** Multichannel per-slice cache: z → the N channel TiledImages for that slice\n   *  (additively composited by OSD; index = channel). Only the active slice's\n   *  visible channels have opacity > 0. */\n  private channelSliceItems = new Map<number, any[]>();\n  /** Cached multichannel slices whose tiles were tinted before the latest\n   *  display change; re-tinted lazily when next revealed by z-scrub. */\n  private staleSlices = new Set<number>();\n  /** Most-recently-shown z last; drives LRU eviction. */\n  private sliceLru: number[] = [];\n  /** z-slices whose tiled image is being added (dedupe rapid scrubbing). */\n  private slicesLoading = new Set<number>();\n  /** Bumped whenever the loaded image changes; in-flight background slice adds\n   *  captured under an older token are dropped (cancelled image switch). */\n  private sliceLoadToken = 0;\n  /** The slice the background loader is currently waiting on (its tiles are\n   *  still streaming): addTiledImage 'success' fires on add, not on tile load,\n   *  so we gate the next slice on getFullyLoaded(). */\n  private bgLoadingZ: number | null = null;\n  /** When bgLoadingZ started loading — a fallback so a slow/stuck slice can't\n   *  stall the whole background pass forever. */\n  private bgLoadingSince = 0;\n  /** Slices the background loader has already attempted (no tight retry loop). */\n  private bgAttempted = new Set<number>();\n  /** Max cached slice tiled images kept resident before LRU eviction. */\n  private maxCachedSlices = 8;\n  /** Upper bound on resident slices, regardless of stack depth (memory guard). */\n  private readonly MAX_CACHED_SLICES_CAP = 64;\n  /** Fit-view tile budget above which background preloading is skipped: a huge\n   *  no-pyramid stack would preload every slice at full resolution and\n   *  flood/timeout. Normal stacks stay below it and KEEP the flicker-free\n   *  pre-cache. */\n  private readonly MAX_PREFETCH_FIT_TILES = 256;\n  /** True only for stacks too large to background-preload. */\n  private skipSlicePrefetch = false;\n  private prefetchTimer: any = null;\n\n  constructor(private host: SliceCacheHost) {}\n\n  // ── configuration (per image, from plot()) ────────────────────────────\n\n  /** Size the cache for the loaded image: keep the whole stack resident\n   *  (capped) so the background loader fills every slice without evicting\n   *  itself; skip preloading entirely when even the coarsest level's tile\n   *  grid is too large (its slices only exist at full resolution). */\n  configure(stackDepth: number, coarseFitTiles: number): void {\n    this.skipSlicePrefetch = coarseFitTiles > this.MAX_PREFETCH_FIT_TILES;\n    this.maxCachedSlices =\n      stackDepth > 1 ? Math.min(this.MAX_CACHED_SLICES_CAP, stackDepth) : 1;\n  }\n\n  /** Current LRU cap (the viewer sizes its tile cache from it). */\n  maxSlices(): number {\n    return this.maxCachedSlices;\n  }\n\n  /** Drop the per-channel groups (on a fresh plot). */\n  clearChannelGroups(): void {\n    this.channelSliceItems.clear();\n  }\n\n  /** Seed the cache with the just-opened composite slice (world item 0), so\n   *  scrubbing back to it later is an instant opacity toggle, not a re-open. */\n  seedComposite(z: number, item: any): void {\n    this.sliceItems.set(z, item);\n    this.touchSliceLru(z);\n  }\n\n  // ── slice display (setZIndex's cache work) ────────────────────────────\n\n  /** Show slice z: reveal it instantly when cached (re-tinting a stale\n   *  multichannel group), otherwise add it once. The current slice stays\n   *  visible until the new one is in — no white-flicker. */\n  showSlice(z: number): void {\n    if (this.host.isMultiChannel()) {\n      const group = this.channelSliceItems.get(z);\n      if (group && group.length && group.some((it) => it && this.sliceInWorld(it))) {\n        this.revealChannelSlice(z);\n        // If a display change happened while this slice was cached, its tiles\n        // hold a stale tint — re-apply now (it's the visible slice, so the\n        // brief restore flash is acceptable, like a fresh load).\n        if (this.staleSlices.delete(z)) this.invalidateSlice(z);\n        this.touchSliceLru(z);\n        this.schedulePrefetch();\n      } else if (!this.slicesLoading.has(z)) {\n        this.addChannelSlice(z);\n      }\n      return;\n    }\n    const cached = this.sliceItems.get(z);\n    if (cached && this.sliceInWorld(cached)) {\n      // Instant: reveal the cached slice, hide the others — no fetch/decode.\n      this.showOnlySlice(z);\n      this.touchSliceLru(z);\n      this.schedulePrefetch();\n      return;\n    }\n    if (this.slicesLoading.has(z)) return; // already being added; success reveals it\n    this.addSlice(z);\n  }\n\n  /** Add a never-seen slice as a hidden tiled image, then reveal it once loaded\n   *  (composite path; multichannel routes to addChannelSlice). */\n  private addSlice(z: number): void {\n    if (!this.host.hasImage()) return;\n    if (this.host.isMultiChannel()) {\n      this.addChannelSlice(z);\n      return;\n    }\n    this.slicesLoading.add(z);\n    // Tag this add to the current image; if the user switches images before it\n    // resolves, the stale callback is dropped (the add belongs to the old stack).\n    const token = this.sliceLoadToken;\n    const ts = this.host.buildTileSource(z);\n    try {\n      // addTiledImage lives on the Viewer (it queues the add into the world).\n      this.host.viewer().addTiledImage({\n        tileSource: ts,\n        x: 0,\n        y: 0,\n        width: 1, // match the primary image's normalized placement\n        opacity: 0,\n        // Load tiles even though it's hidden — this is what lets the background\n        // loader fill every slice's cache so scrubbing gets progressively smoother.\n        preload: true,\n        success: (e: any) => {\n          const item = e?.item;\n          if (token !== this.sliceLoadToken) {\n            // Image switched while this was adding — drop the orphan so it stops\n            // loading instead of streaming tiles for the abandoned stack.\n            if (item) {\n              try { this.host.viewer()?.world?.removeItem(item); } catch { /* gone */ }\n            }\n            return;\n          }\n          this.slicesLoading.delete(z);\n          if (!item) return;\n          this.sliceItems.set(z, item);\n          this.touchSliceLru(z);\n          this.host.onCompositeSliceAdded(z);\n          // Only reveal if the user is still on this slice (fast scrubbing may\n          // have moved on — leave it cached/hidden for a later revisit).\n          if (z === this.host.currentZ()) {\n            this.showOnlySlice(z);\n            this.schedulePrefetch();\n          }\n          this.evictSliceLru();\n        },\n        error: () => {\n          if (token === this.sliceLoadToken) this.slicesLoading.delete(z);\n        },\n      });\n    } catch (err) {\n      this.slicesLoading.delete(z);\n      console.warn('[OSD] failed to add z-slice', err);\n    }\n  }\n\n  /**\n   * Add slice z's channel group: one additively-composited ('lighter' = Fiji\n   * \"Composite\") TiledImage per channel, hidden (opacity 0) until revealed.\n   * Each is preloaded so the background loader can pre-fill every slice.\n   * Cached so a revisit is an instant opacity toggle — no re-fetch, no\n   * white-flicker. Mirrors addSlice for the composite path.\n   */\n  addChannelSlice(z: number): void {\n    if (!this.host.hasImage()) return;\n    if (this.channelSliceItems.has(z) || this.slicesLoading.has(z)) return;\n    this.slicesLoading.add(z);\n    const token = this.sliceLoadToken;\n    const n = this.host.channelCount();\n    const group: any[] = new Array(n);\n    let settled = 0;\n    const onSettled = () => {\n      if (++settled < n) return;\n      if (token !== this.sliceLoadToken) return; // image switched mid-add\n      this.slicesLoading.delete(z);\n      this.channelSliceItems.set(z, group);\n      this.staleSlices.delete(z); // freshly tinted at the current display state\n      this.touchSliceLru(z);\n      if (z === this.host.currentZ()) {\n        this.revealChannelSlice(z); // tiles may still be decoding; opacity is set now\n        this.schedulePrefetch();\n      }\n      this.evictSliceLru();\n    };\n    for (let c = 0; c < n; c++) {\n      try {\n        this.host.viewer().addTiledImage({\n          tileSource: this.host.buildTileSource(z, c),\n          x: 0, y: 0, width: 1,\n          opacity: 0, // revealed by revealChannelSlice once the group is in\n          compositeOperation: 'lighter',\n          preload: true,\n          success: (e: any) => {\n            const item = e?.item;\n            if (token !== this.sliceLoadToken) {\n              if (item) { try { this.host.viewer()?.world?.removeItem(item); } catch { /* gone */ } }\n              return;\n            }\n            if (item) group[c] = item;\n            onSettled();\n          },\n          error: () => onSettled(),\n        });\n      } catch (err) {\n        console.warn('[OSD] failed to add channel slice image', z, c, err);\n        onSettled();\n      }\n    }\n  }\n\n  /** Reveal slice z's channel group (each visible channel → opacity 1) and\n   *  hide every other cached slice's group. Instant; no fetch/decode. */\n  revealChannelSlice(z: number): void {\n    for (const [zz, group] of this.channelSliceItems) {\n      const active = zz === z;\n      group.forEach((it, c) => {\n        if (!it) return;\n        const visible = this.host.channelVisible(c);\n        try { it.setOpacity(active && visible ? 1 : 0); } catch { /* gone */ }\n      });\n    }\n  }\n\n  /** Show the given composite slice (opacity 1) and hide all other cached slices. */\n  private showOnlySlice(z: number): void {\n    for (const [zz, item] of this.sliceItems) {\n      try { item.setOpacity(zz === z ? 1 : 0); } catch { /* item gone */ }\n    }\n  }\n\n  // ── display invalidation (multichannel) ───────────────────────────────\n\n  /** Re-tint after a display change: invalidate ONLY the visible slice's\n   *  channel images — invalidating the whole world would re-process every\n   *  hidden/preloaded slice's tiles (hundreds), flooding OSD and wasting work\n   *  on tiles that aren't on screen. The other cached slices are marked stale\n   *  and re-tinted lazily when revealed. */\n  invalidateChannelDisplay(z: number): void {\n    this.invalidateSlice(z);\n    this.staleSlices.clear();\n    for (const zz of this.channelSliceItems.keys()) {\n      if (zz !== z) this.staleSlices.add(zz);\n    }\n  }\n\n  /** Invalidate (restore + re-recolor) just the channel images of one cached\n   *  slice. A shared timestamp batches the per-image invalidations into one\n   *  processing pass (OSD dedupes tiles already stamped at >= tStamp). */\n  private invalidateSlice(z: number): void {\n    const group = this.channelSliceItems.get(z) ?? [];\n    if (!group.length) return;\n    const osd: any = OSD;\n    const tStamp = typeof osd.now === 'function' ? osd.now() : Date.now();\n    for (const it of group) {\n      if (it && typeof it.requestInvalidate === 'function') {\n        try { it.requestInvalidate(true, false, tStamp); } catch { /* gone */ }\n      }\n    }\n  }\n\n  // ── background stack preloading ───────────────────────────────────────\n\n  /** Debounce so a burst of viewport/slice events coalesces, then advance the\n   *  background stack loader by one slice. */\n  schedulePrefetch(): void {\n    if (this.skipSlicePrefetch) return;\n    if (this.prefetchTimer) clearTimeout(this.prefetchTimer);\n    this.prefetchTimer = setTimeout(() => this.loadNextBackgroundSlice(), 200);\n  }\n\n  /**\n   * Background-load the whole stack: add each not-yet-cached slice as a\n   * hidden, preloaded tiled image, one at a time, working outward from the\n   * current slice — and never blocking the visible slice (it yields while the\n   * current view is still streaming tiles; only one slice is in flight at a\n   * time so the on-screen tiles always win the connection).\n   */\n  private loadNextBackgroundSlice(): void {\n    this.prefetchTimer = null;\n    if (!this.host.hasImage()) return;\n    const sliceCount = this.host.sliceCount();\n    if (sliceCount <= 1) return; // not a stack — nothing to preload\n    // Yield to the visible slice while it's still streaming tiles.\n    if (this.sliceTilesLoading(this.host.currentZ())) {\n      this.schedulePrefetch();\n      return;\n    }\n    // Gate on the in-flight slice's TILES finishing — addTiledImage's success\n    // fires on add, not on tile load, so without this we'd add the whole stack\n    // at once and flood the connection. A time fallback prevents a stuck slice\n    // from stalling the pass.\n    if (this.bgLoadingZ != null) {\n      const adding = this.slicesLoading.has(this.bgLoadingZ);\n      const tilesLoading = this.sliceTilesLoading(this.bgLoadingZ);\n      const timedOut = Date.now() - this.bgLoadingSince > 8000;\n      if ((adding || tilesLoading) && !timedOut) {\n        this.schedulePrefetch();\n        return;\n      }\n      this.bgLoadingZ = null; // that slice's tiles are in (or gave up) — advance\n    }\n    const next = this.nearestUncachedSlice(sliceCount);\n    if (next == null) return; // whole stack cached — done\n    this.bgLoadingZ = next;\n    this.bgLoadingSince = Date.now();\n    this.bgAttempted.add(next);\n    this.addSlice(next); // hidden + preload (added with opacity 0; not revealed)\n    this.schedulePrefetch(); // poll until its tiles load, then advance\n  }\n\n  /** The not-yet-cached slice closest to the current one (load nearest first),\n   *  skipping any already attempted so a failed/slow one isn't retried in a loop. */\n  private nearestUncachedSlice(sliceCount: number): number | null {\n    const cur = this.host.currentZ();\n    for (let d = 0; d < sliceCount; d++) {\n      const candidates = d === 0 ? [cur] : [cur - d, cur + d];\n      for (const z of candidates) {\n        if (\n          z >= 0 && z < sliceCount &&\n          !this.sliceCacheHas(z) && !this.slicesLoading.has(z) && !this.bgAttempted.has(z)\n        ) {\n          return z;\n        }\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Stop background stack preloading and invalidate any in-flight slice add.\n   * Called when a different image is selected so the previous stack stops\n   * loading immediately instead of finishing in the background.\n   */\n  cancelBackgroundLoad(): void {\n    if (this.prefetchTimer) {\n      clearTimeout(this.prefetchTimer);\n      this.prefetchTimer = null;\n    }\n    this.slicesLoading.clear();\n    this.bgLoadingZ = null;\n    this.bgAttempted.clear();\n    this.sliceLoadToken++; // drop pending addTiledImage callbacks from the old image\n    // Abort in-flight background tiles immediately by dropping the hidden\n    // preloaded slices (removeItem cancels their pending tile loads). Keep the\n    // visible slice so the current view doesn't blank before the next plot.\n    this.dropHiddenSlices();\n  }\n\n  /** Remove every cached slice except the currently displayed one, aborting\n   *  their in-flight tile requests. */\n  private dropHiddenSlices(): void {\n    const v = this.host.viewer();\n    if (!v) return;\n    const cur = this.host.currentZ();\n    for (const [z, item] of [...this.sliceItems]) {\n      if (z === cur) continue;\n      this.sliceItems.delete(z);\n      try { v.world.removeItem(item); } catch { /* already gone */ }\n    }\n    for (const [z, group] of [...this.channelSliceItems]) {\n      if (z === cur) continue;\n      this.channelSliceItems.delete(z);\n      for (const it of group) { if (it) { try { v.world.removeItem(it); } catch { /* gone */ } } }\n    }\n    this.sliceLru = this.sliceCacheHas(cur) ? [cur] : [];\n  }\n\n  // ── cache bookkeeping ─────────────────────────────────────────────────\n\n  /** Whether slice z is in the active cache (composite single image, or the\n   *  multichannel per-channel group). */\n  private sliceCacheHas(z: number): boolean {\n    return this.host.isMultiChannel() ? this.channelSliceItems.has(z) : this.sliceItems.has(z);\n  }\n\n  /** The cached TiledImage(s) for slice z (0–1 for composite, N for multichannel). */\n  private sliceGroup(z: number): any[] {\n    if (this.host.isMultiChannel()) return this.channelSliceItems.get(z) ?? [];\n    const it = this.sliceItems.get(z);\n    return it ? [it] : [];\n  }\n\n  /** Whether slice z's tiles are still streaming (any cached image not fully loaded). */\n  private sliceTilesLoading(z: number): boolean {\n    const g = this.sliceGroup(z);\n    if (!g.length) return false;\n    return g.some((it) => it && typeof it.getFullyLoaded === 'function' && !it.getFullyLoaded());\n  }\n\n  /** Remove slice z's cached image(s) from the world and the active cache. */\n  private removeCachedSlice(z: number): void {\n    const v = this.host.viewer();\n    if (this.host.isMultiChannel()) {\n      const group = this.channelSliceItems.get(z);\n      this.channelSliceItems.delete(z);\n      if (group && v) for (const it of group) { if (it) { try { v.world.removeItem(it); } catch { /* gone */ } } }\n    } else {\n      const item = this.sliceItems.get(z);\n      this.sliceItems.delete(z);\n      if (item && v) { try { v.world.removeItem(item); } catch { /* gone */ } }\n    }\n  }\n\n  /** Is the tiled image still in the world (not evicted)? */\n  private sliceInWorld(item: any): boolean {\n    try {\n      return this.host.viewer().world.getIndexOfItem(item) >= 0;\n    } catch {\n      return false;\n    }\n  }\n\n  /** Mark z as most-recently-used. */\n  private touchSliceLru(z: number): void {\n    const i = this.sliceLru.indexOf(z);\n    if (i >= 0) this.sliceLru.splice(i, 1);\n    this.sliceLru.push(z);\n  }\n\n  /** Drop the least-recently-used cached slices beyond the cap (never the\n   *  current one), removing their tiled images so memory stays bounded. */\n  private evictSliceLru(): void {\n    while (this.sliceLru.length > this.maxCachedSlices) {\n      const cur = this.host.currentZ();\n      const idx = this.sliceLru.findIndex((z) => z !== cur);\n      if (idx < 0) break;\n      const z = this.sliceLru.splice(idx, 1)[0];\n      this.removeCachedSlice(z);\n    }\n  }\n\n  /** Clear the cache (on teardown / image switch). */\n  reset(): void {\n    this.sliceItems.clear();\n    this.channelSliceItems.clear();\n    this.staleSlices.clear();\n    this.sliceLru = [];\n    this.slicesLoading.clear();\n    this.bgLoadingZ = null;\n    this.bgAttempted.clear();\n  }\n}\n"]}

package/esm2022/lib/implementations/osd/tile-client.mjs

@@ -0,0 +1,29 @@
+import { firstValueFrom } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+/** Build the `/tile` request URL — the one place its query shape lives. */
+export function buildTileUrl(api, infoB64, c) {
+    const ch = c.channel == null ? '' : `&channel=${c.channel}`;
+    return `${api}tile?info=${infoB64}&res=${c.res}&col=${c.col}&row=${c.row}&z=${c.z}&tileSize=${c.tileSize}${ch}`;
+}
+/** Fetch a tile PNG and decode it to an ImageBitmap. The caller owns the
+ *  bitmap (call `close()` when done). Throws on network/decode failure. */
+export async function fetchTileBitmap(http, url, timeoutMs) {
+    const blob = await firstValueFrom(http.get(url, { responseType: 'blob' }).pipe(timeout(timeoutMs)));
+    return createImageBitmap(blob);
+}
+/** Fetch a tile and read its pixels back as RGBA ImageData (via an offscreen
+ *  canvas). Returns null only when a 2d context can't be created; throws on
+ *  network/decode failure (the caller's tagged catch handles it). */
+export async function fetchTileRgba(http, url, timeoutMs) {
+    const bmp = await fetchTileBitmap(http, url, timeoutMs);
+    const cv = document.createElement('canvas');
+    cv.width = bmp.width;
+    cv.height = bmp.height;
+    const ctx = cv.getContext('2d', { willReadFrequently: true });
+    if (!ctx)
+        return null;
+    ctx.drawImage(bmp, 0, 0);
+    bmp.close?.();
+    return ctx.getImageData(0, 0, cv.width, cv.height);
+}
+//# sourceMappingURL=data:application/json;base64,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