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

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

@@ -0,0 +1,330 @@
+import { combineLatest } from 'rxjs';
+import { quiet } from './osd-lib';
+import { DisplayPipeline } from './display-pipeline';
+import { buildColormapLut } from '../../contracts/colormap-lut';
+/**
+ * Client-side display for OpenSeadragon tiles: window/gamma/colormap/invert and
+ * per-channel tints, applied through OSD's `tile-invalidated` pixel pipeline.
+ *
+ * Owns the display state mirrored from the shared {@link VisualizerStore} (the
+ * LUT, the channel states, invert) and the recolor invariant: invalidations are
+ * coalesced to one per animation frame, and every round captures
+ * {@link displayToken} — a round that a newer one has superseded must not write
+ * its pixels back.
+ */
+export class OsdTileRecolorer {
+    constructor(host, store) {
+        this.host = host;
+        this.store = store;
+        /** Pixel display pipeline (window/gamma/invert/colormap + additive tint) —
+         *  shared by tile recoloring, the serverless compositor and the composite
+         *  export so they stay identical (see DisplayPipeline). */
+        this.display = new DisplayPipeline({
+            isGrayscale: () => this.host.isGrayscale(),
+            colorLut: () => this.colorLut,
+            channelStates: () => this.channelStates,
+            invertBg: () => this.invertBg,
+        });
+        /** 256-entry RGB LUT for the active colormap, applied to grayscale tiles
+         *  (mirrors Plotly's heatmap colorscale). Null while options resolve;
+         *  recoloring is skipped until it's built. */
+        this.colorLut = null;
+        /** Latest per-channel display state (window/gamma/visibility) from the store,
+         *  read synchronously by recolorTile. Channel 0 drives grayscale windowing;
+         *  R/G/B (indices 0-2) drive RGB per-channel windowing. */
+        this.channelStates = [];
+        /** Inverted background (white = zero): inverts the windowed value before the
+         *  gamma and the LUT (grayscale) / per channel before the additive merge (RGB
+         *  and multichannel), as napari-js does. */
+        this.invertBg = false;
+        /** Bumped by every display invalidation. A recolor round captures it and, after
+         *  each `await`, abandons the tile once a newer round has started. Writing a
+         *  superseded context back is not merely wasted work: OSD's conversion sees a
+         *  canvas the newer round already replaced, throws `DOMException`, and
+         *  `_handleConversionError` DESTROYS the cache record and unloads the tile
+         *  (unlike the drawer's rasterBlob path, it does not re-prepare). Enough of
+         *  those and the viewer goes white mid-drag. */
+        this.displayToken = 0;
+        /** Pending coalesced invalidation (see {@link scheduleInvalidate}). */
+        this.invalidateHandle = null;
+        this.sub = null;
+    }
+    /** Whether display round `token` is still the current one. */
+    isCurrent(token) {
+        return token === this.displayToken;
+    }
+    /**
+     * Subscribe to the shared VisualizerStore colormap/reverse so OSD recolors in
+     * lock-step with Plotly. Idempotent and self-healing: the service is a root
+     * singleton, but `unsubscribe()` (called on VisualizerComponent destroy)
+     * tears the subscription down — and the constructor never runs again. So
+     * `plot()` calls this to re-establish it after a component teardown/recreate
+     * (e.g. switching images), otherwise colormap changes would be silently
+     * dropped on every image after the first switch.
+     */
+    ensureSubscription() {
+        if (this.sub)
+            return;
+        // Colormap/reverse + per-channel window/gamma/visibility + invert all live in
+        // the shared VisualizerStore. Rebuild the LUT and re-run the pixel pipeline
+        // whenever any of them changes, so the Channels & Histogram pane updates the
+        // image live and OSD stays in lock-step with Plotly.
+        this.sub = combineLatest([
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getChannelStates(),
+            this.store.getInvert(),
+        ]).subscribe(([cm, rev, channels, invert]) => {
+            this.colorLut = buildColormapLut(cm?.data?.value, !!rev);
+            this.channelStates = channels;
+            this.invertBg = !!invert;
+            // Multichannel: each channel is its own TiledImage — visibility is the
+            // image's opacity (window/gamma/colour are applied by recolorChannelTile
+            // on the invalidate below). Re-applying the current slice's reveal picks up
+            // the new per-channel visibility (cached slices stay hidden).
+            if (this.host.isMultiChannel()) {
+                this.host.revealChannelSlice(this.host.currentZ());
+            }
+            // requestInvalidate(true) restores each tile to its original data before
+            // re-running recolorTile, so a change always maps afresh (no compounding).
+            // RGB now recolors too (per-channel window/visibility), so don't gate on
+            // grayscale. Coalesced: PrimeNG's slider fires (onChange) continuously, so
+            // a single drag would otherwise queue dozens of overlapping restore +
+            // re-process rounds over every channel image. (Serverless multichannel
+            // re-composites from its cached planes instead — see invalidateDisplay.)
+            this.scheduleInvalidate();
+        });
+    }
+    /** Tear the store subscription down and drop a queued invalidation, so it
+     *  can't fire against a torn-down viewer. */
+    unsubscribe() {
+        this.sub?.unsubscribe();
+        this.sub = null;
+        if (this.invalidateHandle !== null) {
+            if (typeof cancelAnimationFrame === 'function')
+                cancelAnimationFrame(this.invalidateHandle);
+            else
+                clearTimeout(this.invalidateHandle);
+            this.invalidateHandle = null;
+        }
+    }
+    /** Seed the Intensity channel with a measured auto-window while it's still
+     *  at full range (never clobber the user's manual window); if the user
+     *  already windowed, just re-invalidate so painted tiles pick the LUT up. */
+    seedGrayWindow(min, max) {
+        const ch0 = this.store.currentChannelStates()[0];
+        if (ch0 && ch0.min === 0 && ch0.max === 255) {
+            this.store.setChannelState(0, { min, max });
+        }
+        else if (this.host.viewer() && this.colorLut) {
+            // Coalesced (and visible-slice-only for multichannel) — not a raw
+            // whole-world restore + re-recolor per sampled slice.
+            this.scheduleInvalidate();
+        }
+    }
+    /**
+     * Hook a freshly opened viewer (and its navigator, a separate mini-viewer with
+     * its own tiles that doesn't receive the main viewer's events) into the pixel
+     * pipeline, and paint what is already loaded when there is anything to apply.
+     */
+    attach(viewer) {
+        // The handler runs per tile on load (and on requestInvalidate); recoloring
+        // is a no-op for RGB images at default display or before the LUT resolves.
+        viewer.addHandler('tile-invalidated', (event) => this.recolorTile(event));
+        viewer.navigator?.addHandler('tile-invalidated', (event) => this.recolorTile(event));
+        if ((this.host.isGrayscale() && this.colorLut) || this.host.isMultiChannel())
+            this.invalidateWorld();
+    }
+    /** Collapse a burst of display-state changes into ONE invalidation on the next
+     *  frame. Dragging a window slider emits per pixel of travel, and each round
+     *  restores and re-processes every tile of every channel — so the burst is both
+     *  wasted work and the race that breaks cache records (see {@link displayToken}).
+     *  The store write stays live, so the pane itself remains responsive. */
+    scheduleInvalidate() {
+        if (this.invalidateHandle !== null)
+            return; // already queued for this frame
+        const raf = typeof requestAnimationFrame === 'function'
+            ? requestAnimationFrame
+            : (cb) => setTimeout(() => cb(0), 16);
+        this.invalidateHandle = raf(() => {
+            this.invalidateHandle = null;
+            this.invalidateDisplay();
+        });
+    }
+    /** Re-apply the display pipeline (window/gamma/colour/invert) after a state change.
+     *  Multichannel invalidates ONLY the visible slice's channel images — invalidating
+     *  the whole world would re-process every hidden/preloaded slice's tiles (hundreds),
+     *  flooding OSD with "[CacheRecord] … InvalidStateError" and wasting work on tiles
+     *  that aren't on screen. The other cached slices are marked stale and re-tinted
+     *  lazily when revealed. Composite/grayscale invalidate the world; serverless
+     *  multichannel re-composites its cached planes. */
+    invalidateDisplay() {
+        // Supersede any in-flight recolor round before restarting one (see displayToken).
+        this.displayToken++;
+        if (!this.host.viewer())
+            return;
+        if (this.host.isSimpleMultichannel()) {
+            this.host.recomposite(this.displayToken);
+            return;
+        }
+        if (this.host.isMultiChannel()) {
+            this.host.invalidateChannelDisplay(this.host.currentZ());
+            return;
+        }
+        this.invalidateWorld();
+    }
+    /** Restore and re-recolor every tile of the main viewer and the navigator. */
+    invalidateWorld() {
+        const v = this.host.viewer();
+        if (!v)
+            return;
+        quiet(() => v.world.requestInvalidate(true));
+        quiet(() => v.navigator?.world?.requestInvalidate(true));
+    }
+    /**
+     * Recolor a grayscale tile through the active colormap LUT, using OSD's
+     * tile-invalidated pixel pipeline (OSD 5+/6). Maps each pixel's grayscale
+     * value (r==g==b) to the LUT's RGB. No-op for RGB images or until the LUT is
+     * built. Handler is async — OSD awaits it (raiseEventAwaiting).
+     */
+    async recolorTile(event) {
+        if (this.host.isMultiChannel()) {
+            await this.recolorChannelTile(event);
+            return;
+        }
+        // A serverless multichannel composite is drawn in the display colours already
+        // (recomposite): recolouring its tiles as RGB applied the window, gamma and
+        // invert a second time.
+        if (this.host.isSimpleMultichannel())
+            return;
+        const token = this.displayToken;
+        if (this.host.isGrayscale()) {
+            if (!this.colorLut)
+                return;
+        }
+        else if (!this.display.rgbNeedsRecolor()) {
+            return; // RGB at default (all visible, full window, γ=1, no invert) → passthrough
+        }
+        const px = await this.readTilePixels(event);
+        if (!px || !this.display.applyToRgba(px.img.data))
+            return; // nothing opaque
+        await this.writeTilePixels(event, px, token);
+    }
+    /**
+     * Tint a single channel's tile in place. Each channel is its own OpenSeadragon
+     * TiledImage (a single-band grayscale tile); OSD composites the N images
+     * additively ('lighter') in its drawer — so this just maps the tile's intensity
+     * through the channel's window/gamma and its pseudo-colour. Synchronous (no
+     * cross-tile fetch) → no race, no seams. Channel is parsed from the tile URL.
+     */
+    async recolorChannelTile(event) {
+        const token = this.displayToken;
+        const tile = event?.tile;
+        const url = (tile && (typeof tile.getUrl === 'function' ? tile.getUrl() : tile.url)) || '';
+        const m = /[?&]channel=(\d+)/.exec(url);
+        const ch = m ? parseInt(m[1], 10) : 0;
+        const st = this.channelStates[ch];
+        const px = await this.readTilePixels(event);
+        if (!px)
+            return;
+        // Precompute lum(0..255) → tinted RGB once, then map each pixel by lookup —
+        // the channel tile is single-band, so this turns ~262k per-pixel
+        // channelIntensity() (with Math.pow for gamma) calls into 256 — the difference
+        // between a snappy and a sluggish slider on a 4-channel stack.
+        const { r: rL, g: gL, b: bL } = this.display.channelRgbLut(st);
+        const d = px.img.data;
+        let changed = false;
+        for (let i = 0; i < d.length; i += 4) {
+            if (d[i + 3] === 0)
+                continue;
+            const r = d[i], g = d[i + 1], b = d[i + 2];
+            const lum = r >= g ? (r >= b ? r : b) : g >= b ? g : b; // single-band → max
+            d[i] = rL[lum];
+            d[i + 1] = gL[lum];
+            d[i + 2] = bL[lum];
+            changed = true;
+        }
+        if (!changed)
+            return;
+        await this.writeTilePixels(event, px, token);
+    }
+    /**
+     * Read a tile's pixels for recoloring. Prefers the tile's rendering context,
+     * but some tile caches (ajax PNG blobs) convert to an *empty* context2d —
+     * recoloring that would blank the tile (white canvas). So if the context has
+     * no opaque pixels, the tile's own bitmap/image is drawn to a scratch canvas
+     * and read instead. Null when no pixels can be read: leave the tile untouched.
+     */
+    async readTilePixels(event) {
+        let ctx = null;
+        try {
+            ctx = (await event.getData('context2d'));
+        }
+        catch {
+            /* try the bitmap below */
+        }
+        if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {
+            let img = null;
+            try {
+                img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+            }
+            catch {
+                /* tainted/gone */
+            }
+            if (img && hasOpaque(img.data))
+                return { ctx, img };
+        }
+        let src = null;
+        try {
+            src = (await event.getData('imageBitmap'));
+        }
+        catch {
+            /* try the image below */
+        }
+        if (!src || !src.width) {
+            try {
+                src = (await event.getData('image'));
+            }
+            catch {
+                /* none */
+            }
+        }
+        if (!src || !src.width)
+            return null;
+        const c = document.createElement('canvas');
+        c.width = src.width;
+        c.height = src.height;
+        const scratch = c.getContext('2d', { willReadFrequently: true });
+        if (!scratch)
+            return null;
+        scratch.drawImage(src, 0, 0);
+        return { ctx: scratch, img: scratch.getImageData(0, 0, c.width, c.height) };
+    }
+    /** Write recolored pixels back to the tile — unless a newer display round
+     *  (`token`, see {@link displayToken}) has already restored it: writing a
+     *  superseded context back makes OSD's conversion throw DOMException, which
+     *  destroys the cache record and unloads the tile. */
+    async writeTilePixels(event, px, token) {
+        if (token !== this.displayToken)
+            return;
+        px.ctx.putImageData(px.img, 0, 0);
+        // The tile's cache can still be evicted between the awaits and here (a
+        // slice change), making setData throw a DOMException on a dead canvas.
+        // Swallow it — the tile is gone, so there's nothing to recolor.
+        try {
+            await event.setData(px.ctx, 'context2d');
+        }
+        catch {
+            /* tile evicted */
+        }
+    }
+}
+/** True if any pixel in the RGBA buffer is non-transparent. */
+function hasOpaque(d) {
+    for (let i = 3; i < d.length; i += 4) {
+        if (d[i] !== 0)
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tile-recolor.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/tile-recolor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription, combineLatest } from 'rxjs';\nimport type * as OpenSeadragon from 'openseadragon';\n\nimport { quiet } from './osd-lib';\nimport { DisplayPipeline } from './display-pipeline';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { buildColormapLut, Rgb } from '../../contracts/colormap-lut';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\n\n/** The service state the recolorer reads — live, so it follows a viewer rebuild. */\nexport interface TileRecolorHost {\n  viewer(): OpenSeadragon.Viewer | null;\n  isGrayscale(): boolean;\n  isMultiChannel(): boolean;\n  /** Serverless multichannel: recolor by re-compositing the cached planes. */\n  isSimpleMultichannel(): boolean;\n  currentZ(): number;\n  /** Re-apply the current slice's per-channel visibility (multichannel). */\n  revealChannelSlice(z: number): void;\n  /** Invalidate only the visible slice's channel images (multichannel). */\n  invalidateChannelDisplay(z: number): void;\n  /** Re-composite the serverless-multichannel planes for display round `token`. */\n  recomposite(token: number): void;\n}\n\n/** The tile-invalidated event's pixel accessors (OSD 5+/6), as used here. */\ninterface TileEvent {\n  tile?: { getUrl?: () => string; url?: string };\n  getData(type: string): Promise<unknown>;\n  setData(data: unknown, type: string): Promise<unknown>;\n}\n\ntype TilePixels = { ctx: CanvasRenderingContext2D; img: ImageData };\n\n/**\n * Client-side display for OpenSeadragon tiles: window/gamma/colormap/invert and\n * per-channel tints, applied through OSD's `tile-invalidated` pixel pipeline.\n *\n * Owns the display state mirrored from the shared {@link VisualizerStore} (the\n * LUT, the channel states, invert) and the recolor invariant: invalidations are\n * coalesced to one per animation frame, and every round captures\n * {@link displayToken} — a round that a newer one has superseded must not write\n * its pixels back.\n */\nexport class OsdTileRecolorer {\n  /** Pixel display pipeline (window/gamma/invert/colormap + additive tint) —\n   *  shared by tile recoloring, the serverless compositor and the composite\n   *  export so they stay identical (see DisplayPipeline). */\n  readonly display = new DisplayPipeline({\n    isGrayscale: () => this.host.isGrayscale(),\n    colorLut: () => this.colorLut,\n    channelStates: () => this.channelStates,\n    invertBg: () => this.invertBg,\n  });\n  /** 256-entry RGB LUT for the active colormap, applied to grayscale tiles\n   *  (mirrors Plotly's heatmap colorscale). Null while options resolve;\n   *  recoloring is skipped until it's built. */\n  colorLut: Rgb[] | null = null;\n  /** Latest per-channel display state (window/gamma/visibility) from the store,\n   *  read synchronously by recolorTile. Channel 0 drives grayscale windowing;\n   *  R/G/B (indices 0-2) drive RGB per-channel windowing. */\n  channelStates: IChannelState[] = [];\n  /** Inverted background (white = zero): inverts the windowed value before the\n   *  gamma and the LUT (grayscale) / per channel before the additive merge (RGB\n   *  and multichannel), as napari-js does. */\n  invertBg = false;\n  /** Bumped by every display invalidation. A recolor round captures it and, after\n   *  each `await`, abandons the tile once a newer round has started. Writing a\n   *  superseded context back is not merely wasted work: OSD's conversion sees a\n   *  canvas the newer round already replaced, throws `DOMException`, and\n   *  `_handleConversionError` DESTROYS the cache record and unloads the tile\n   *  (unlike the drawer's rasterBlob path, it does not re-prepare). Enough of\n   *  those and the viewer goes white mid-drag. */\n  displayToken = 0;\n  /** Pending coalesced invalidation (see {@link scheduleInvalidate}). */\n  private invalidateHandle: number | null = null;\n  private sub: Subscription | null = null;\n\n  constructor(\n    private readonly host: TileRecolorHost,\n    private readonly store: VisualizerStore,\n  ) {}\n\n  /** Whether display round `token` is still the current one. */\n  isCurrent(token: number): boolean {\n    return token === this.displayToken;\n  }\n\n  /**\n   * Subscribe to the shared VisualizerStore colormap/reverse so OSD recolors in\n   * lock-step with Plotly. Idempotent and self-healing: the service is a root\n   * singleton, but `unsubscribe()` (called on VisualizerComponent destroy)\n   * tears the subscription down — and the constructor never runs again. So\n   * `plot()` calls this to re-establish it after a component teardown/recreate\n   * (e.g. switching images), otherwise colormap changes would be silently\n   * dropped on every image after the first switch.\n   */\n  ensureSubscription(): void {\n    if (this.sub) return;\n    // Colormap/reverse + per-channel window/gamma/visibility + invert all live in\n    // the shared VisualizerStore. Rebuild the LUT and re-run the pixel pipeline\n    // whenever any of them changes, so the Channels & Histogram pane updates the\n    // image live and OSD stays in lock-step with Plotly.\n    this.sub = combineLatest([\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getChannelStates(),\n      this.store.getInvert(),\n    ]).subscribe(([cm, rev, channels, invert]) => {\n      this.colorLut = buildColormapLut(cm?.data?.value, !!rev);\n      this.channelStates = channels;\n      this.invertBg = !!invert;\n      // Multichannel: each channel is its own TiledImage — visibility is the\n      // image's opacity (window/gamma/colour are applied by recolorChannelTile\n      // on the invalidate below). Re-applying the current slice's reveal picks up\n      // the new per-channel visibility (cached slices stay hidden).\n      if (this.host.isMultiChannel()) {\n        this.host.revealChannelSlice(this.host.currentZ());\n      }\n      // requestInvalidate(true) restores each tile to its original data before\n      // re-running recolorTile, so a change always maps afresh (no compounding).\n      // RGB now recolors too (per-channel window/visibility), so don't gate on\n      // grayscale. Coalesced: PrimeNG's slider fires (onChange) continuously, so\n      // a single drag would otherwise queue dozens of overlapping restore +\n      // re-process rounds over every channel image. (Serverless multichannel\n      // re-composites from its cached planes instead — see invalidateDisplay.)\n      this.scheduleInvalidate();\n    });\n  }\n\n  /** Tear the store subscription down and drop a queued invalidation, so it\n   *  can't fire against a torn-down viewer. */\n  unsubscribe(): void {\n    this.sub?.unsubscribe();\n    this.sub = null;\n    if (this.invalidateHandle !== null) {\n      if (typeof cancelAnimationFrame === 'function') cancelAnimationFrame(this.invalidateHandle);\n      else clearTimeout(this.invalidateHandle as unknown as ReturnType<typeof setTimeout>);\n      this.invalidateHandle = null;\n    }\n  }\n\n  /** Seed the Intensity channel with a measured auto-window while it's still\n   *  at full range (never clobber the user's manual window); if the user\n   *  already windowed, just re-invalidate so painted tiles pick the LUT up. */\n  seedGrayWindow(min: number, max: number): void {\n    const ch0 = this.store.currentChannelStates()[0];\n    if (ch0 && ch0.min === 0 && ch0.max === 255) {\n      this.store.setChannelState(0, { min, max });\n    } else if (this.host.viewer() && this.colorLut) {\n      // Coalesced (and visible-slice-only for multichannel) — not a raw\n      // whole-world restore + re-recolor per sampled slice.\n      this.scheduleInvalidate();\n    }\n  }\n\n  /**\n   * Hook a freshly opened viewer (and its navigator, a separate mini-viewer with\n   * its own tiles that doesn't receive the main viewer's events) into the pixel\n   * pipeline, and paint what is already loaded when there is anything to apply.\n   */\n  attach(viewer: OpenSeadragon.Viewer): void {\n    // The handler runs per tile on load (and on requestInvalidate); recoloring\n    // is a no-op for RGB images at default display or before the LUT resolves.\n    viewer.addHandler('tile-invalidated', (event) => this.recolorTile(event as unknown as TileEvent));\n    viewer.navigator?.addHandler('tile-invalidated', (event) => this.recolorTile(event as unknown as TileEvent));\n    if ((this.host.isGrayscale() && this.colorLut) || this.host.isMultiChannel()) this.invalidateWorld();\n  }\n\n  /** Collapse a burst of display-state changes into ONE invalidation on the next\n   *  frame. Dragging a window slider emits per pixel of travel, and each round\n   *  restores and re-processes every tile of every channel — so the burst is both\n   *  wasted work and the race that breaks cache records (see {@link displayToken}).\n   *  The store write stays live, so the pane itself remains responsive. */\n  scheduleInvalidate(): void {\n    if (this.invalidateHandle !== null) return; // already queued for this frame\n    const raf =\n      typeof requestAnimationFrame === 'function'\n        ? requestAnimationFrame\n        : (cb: FrameRequestCallback) => setTimeout(() => cb(0), 16) as unknown as number;\n    this.invalidateHandle = raf(() => {\n      this.invalidateHandle = null;\n      this.invalidateDisplay();\n    });\n  }\n\n  /** Re-apply the display pipeline (window/gamma/colour/invert) after a state change.\n   *  Multichannel invalidates ONLY the visible slice's channel images — invalidating\n   *  the whole world would re-process every hidden/preloaded slice's tiles (hundreds),\n   *  flooding OSD with \"[CacheRecord] … InvalidStateError\" and wasting work on tiles\n   *  that aren't on screen. The other cached slices are marked stale and re-tinted\n   *  lazily when revealed. Composite/grayscale invalidate the world; serverless\n   *  multichannel re-composites its cached planes. */\n  invalidateDisplay(): void {\n    // Supersede any in-flight recolor round before restarting one (see displayToken).\n    this.displayToken++;\n    if (!this.host.viewer()) return;\n    if (this.host.isSimpleMultichannel()) {\n      this.host.recomposite(this.displayToken);\n      return;\n    }\n    if (this.host.isMultiChannel()) {\n      this.host.invalidateChannelDisplay(this.host.currentZ());\n      return;\n    }\n    this.invalidateWorld();\n  }\n\n  /** Restore and re-recolor every tile of the main viewer and the navigator. */\n  invalidateWorld(): void {\n    const v = this.host.viewer();\n    if (!v) return;\n    quiet(() => v.world.requestInvalidate(true));\n    quiet(() => v.navigator?.world?.requestInvalidate(true));\n  }\n\n  /**\n   * Recolor a grayscale tile through the active colormap LUT, using OSD's\n   * tile-invalidated pixel pipeline (OSD 5+/6). Maps each pixel's grayscale\n   * value (r==g==b) to the LUT's RGB. No-op for RGB images or until the LUT is\n   * built. Handler is async — OSD awaits it (raiseEventAwaiting).\n   */\n  async recolorTile(event: TileEvent): Promise<void> {\n    if (this.host.isMultiChannel()) {\n      await this.recolorChannelTile(event);\n      return;\n    }\n    // A serverless multichannel composite is drawn in the display colours already\n    // (recomposite): recolouring its tiles as RGB applied the window, gamma and\n    // invert a second time.\n    if (this.host.isSimpleMultichannel()) return;\n    const token = this.displayToken;\n    if (this.host.isGrayscale()) {\n      if (!this.colorLut) return;\n    } else if (!this.display.rgbNeedsRecolor()) {\n      return; // RGB at default (all visible, full window, γ=1, no invert) → passthrough\n    }\n\n    const px = await this.readTilePixels(event);\n    if (!px || !this.display.applyToRgba(px.img.data)) return; // nothing opaque\n    await this.writeTilePixels(event, px, token);\n  }\n\n  /**\n   * Tint a single channel's tile in place. Each channel is its own OpenSeadragon\n   * TiledImage (a single-band grayscale tile); OSD composites the N images\n   * additively ('lighter') in its drawer — so this just maps the tile's intensity\n   * through the channel's window/gamma and its pseudo-colour. Synchronous (no\n   * cross-tile fetch) → no race, no seams. Channel is parsed from the tile URL.\n   */\n  async recolorChannelTile(event: TileEvent): Promise<void> {\n    const token = this.displayToken;\n    const tile = event?.tile;\n    const url: string = (tile && (typeof tile.getUrl === 'function' ? tile.getUrl() : tile.url)) || '';\n    const m = /[?&]channel=(\\d+)/.exec(url);\n    const ch = m ? parseInt(m[1], 10) : 0;\n    const st = this.channelStates[ch];\n\n    const px = await this.readTilePixels(event);\n    if (!px) return;\n\n    // Precompute lum(0..255) → tinted RGB once, then map each pixel by lookup —\n    // the channel tile is single-band, so this turns ~262k per-pixel\n    // channelIntensity() (with Math.pow for gamma) calls into 256 — the difference\n    // between a snappy and a sluggish slider on a 4-channel stack.\n    const { r: rL, g: gL, b: bL } = this.display.channelRgbLut(st);\n    const d = px.img.data;\n    let changed = false;\n    for (let i = 0; i < d.length; i += 4) {\n      if (d[i + 3] === 0) continue;\n      const r = d[i],\n        g = d[i + 1],\n        b = d[i + 2];\n      const lum = r >= g ? (r >= b ? r : b) : g >= b ? g : b; // single-band → max\n      d[i] = rL[lum];\n      d[i + 1] = gL[lum];\n      d[i + 2] = bL[lum];\n      changed = true;\n    }\n    if (!changed) return;\n    await this.writeTilePixels(event, px, token);\n  }\n\n  /**\n   * Read a tile's pixels for recoloring. Prefers the tile's rendering context,\n   * but some tile caches (ajax PNG blobs) convert to an *empty* context2d —\n   * recoloring that would blank the tile (white canvas). So if the context has\n   * no opaque pixels, the tile's own bitmap/image is drawn to a scratch canvas\n   * and read instead. Null when no pixels can be read: leave the tile untouched.\n   */\n  private async readTilePixels(event: TileEvent): Promise<TilePixels | null> {\n    let ctx: CanvasRenderingContext2D | null = null;\n    try {\n      ctx = (await event.getData('context2d')) as CanvasRenderingContext2D;\n    } catch {\n      /* try the bitmap below */\n    }\n    if (ctx && ctx.canvas && ctx.canvas.width && ctx.canvas.height) {\n      let img: ImageData | null = null;\n      try {\n        img = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);\n      } catch {\n        /* tainted/gone */\n      }\n      if (img && hasOpaque(img.data)) return { ctx, img };\n    }\n    type Drawable = CanvasImageSource & { width: number; height: number };\n    let src: Drawable | null = null;\n    try {\n      src = (await event.getData('imageBitmap')) as Drawable;\n    } catch {\n      /* try the image below */\n    }\n    if (!src || !src.width) {\n      try {\n        src = (await event.getData('image')) as Drawable;\n      } catch {\n        /* none */\n      }\n    }\n    if (!src || !src.width) return null;\n    const c = document.createElement('canvas');\n    c.width = src.width;\n    c.height = src.height;\n    const scratch = c.getContext('2d', { willReadFrequently: true });\n    if (!scratch) return null;\n    scratch.drawImage(src, 0, 0);\n    return { ctx: scratch, img: scratch.getImageData(0, 0, c.width, c.height) };\n  }\n\n  /** Write recolored pixels back to the tile — unless a newer display round\n   *  (`token`, see {@link displayToken}) has already restored it: writing a\n   *  superseded context back makes OSD's conversion throw DOMException, which\n   *  destroys the cache record and unloads the tile. */\n  private async writeTilePixels(event: TileEvent, px: TilePixels, token: number): Promise<void> {\n    if (token !== this.displayToken) return;\n    px.ctx.putImageData(px.img, 0, 0);\n    // The tile's cache can still be evicted between the awaits and here (a\n    // slice change), making setData throw a DOMException on a dead canvas.\n    // Swallow it — the tile is gone, so there's nothing to recolor.\n    try {\n      await event.setData(px.ctx, 'context2d');\n    } catch {\n      /* tile evicted */\n    }\n  }\n}\n\n/** True if any pixel in the RGBA buffer is non-transparent. */\nfunction hasOpaque(d: Uint8ClampedArray): boolean {\n  for (let i = 3; i < d.length; i += 4) {\n    if (d[i] !== 0) return true;\n  }\n  return false;\n}\n"]}