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

package/esm2022/lib/implementations/napari-js/napari-image-2d-scene.mjs

@@ -0,0 +1,602 @@
+import { MultiChannelImageView, decodeImageRGBA, histogramScalar, tintColormap } from 'napari-js';
+import { NavigatorOverlay, ScaleBarOverlay } from 'napari-js/overlays';
+import { rgbNeedsRecolor } from '../osd/display-pipeline';
+import { regionCentroids } from '../region-centroids';
+import { isServerlessMultichannel, splitRgbBands, tintFor, tintedComposite, toIHistogram, toNapariGamma, typedPlane, } from './napari-helpers';
+/**
+ * Composite additive channel layers onto black, as OSD and Plotly merge them: the bottom-most
+ * SHOWN layer replaces what is under it, the others add onto it. All-additive layers added onto
+ * the viewer's dark-grey background instead, lifting every black pixel to that grey.
+ */
+function mergeOntoBlack(layers) {
+    const base = layers.find((layer) => layer.visible);
+    for (const layer of layers)
+        layer.blending = layer === base ? 'translucent' : 'additive';
+}
+/**
+ * The 2D image (review Appendix B, cluster E): pyramidal `TiledSource`s against the `/tile`
+ * endpoint when `/tiles/info` describes the image, else a single stitched level (`tiled:false`
+ * stacks fetch each slice's own URL, a serverless multichannel stack each channel's own plane);
+ * multichannel additive tints, grayscale colormap or RGB (recoloured per band, see
+ * {@link syncRgbBands}); the coarse histogram samples of the tiled path, the scale bar, the
+ * overview navigator and the 2D interaction stack (region overlay + pixel tools). The
+ * region-centroid scatter and the spatial 2D scene are built over it.
+ */
+export class Image2dScene {
+    constructor(ctx, opts = {}) {
+        this.ctx = ctx;
+        this.opts = opts;
+        /** How the image is composited (drives the histogram and the display-state updates). */
+        this.imageMode = 'rgb';
+        /** True when the image is rendered via pyramidal TiledSources (descriptor available). */
+        this.tiled = false;
+        /** napari-js high-level view owning the per-channel layer set for {@link imageMode}. */
+        this.channelView = null;
+        /** Latest wins for a stitched slice: a slow older slice can't clobber a newer one. */
+        this.sliceReq = 0;
+        /** RGB: the R, G and B bands as layer sources (typed planes, or band `TiledSource`s that share
+         *  one request per tile) and the stitched level's scale — what {@link syncRgbBands} draws. */
+        this.rgbBands = null;
+        /** RGB: the three additive band layers while the channel states recolour the image; null while
+         *  the RGB layer draws it as it is. */
+        this.bandLayers = null;
+        /** Coarse per-channel luminance sample (keyed by channel index) for the histogram in tiled mode,
+         *  where the layers have no full in-memory pixels — and an RGB image's raw bands in either mode.
+         *  Refreshed on mount + slice change. */
+        this.histSamples = new Map();
+        /** Latest-wins token for {@link refreshHistogramSamples}. */
+        this.histGen = 0;
+        /** Physical scale bar overlay (null when the image has no µm/pixel). */
+        this.scaleBar = null;
+        /** Overview minimap (bottom-right), as OSD's navigator. */
+        this.navigator = null;
+        /** Bumped per thumbnail request, so a slow one cannot overwrite a newer slice's. */
+        this.navigatorToken = 0;
+        /** The current slice's per-channel thumbnail bitmaps (multichannel only), kept so a tint or
+         *  visibility change recolours the thumbnail without re-fetching it. */
+        this.navigatorChannels = null;
+        /** The tints/visibility the thumbnail was last composited with — see {@link recolorNavigator}. */
+        this.navigatorTintKey = '';
+        this.displaySub = null;
+    }
+    get hasImage() {
+        return this.opts.image !== false;
+    }
+    async mount() {
+        const { ctx } = this;
+        const z = ctx.z();
+        if (this.hasImage)
+            await this.render(z);
+        // Reset into a newer scene while the image loaded: this scene is already disposed, and the
+        // tool bridge is the next scene's — install nothing more.
+        if (ctx.signal.aborted)
+            return;
+        if (this.opts.fit ? this.opts.fit() : this.hasImage)
+            ctx.fitCameraSoon();
+        this.followDisplayState();
+        // The scale bar and navigator describe an image; with none loaded, whatever they would
+        // read is left over from the last one.
+        if (this.hasImage) {
+            this.installScaleBar();
+            this.installNavigator(z);
+        }
+        ctx.tools.install2dInteraction(ctx.viewer, ctx.host);
+    }
+    setZ(z) {
+        const { ctx } = this;
+        if (this.navigator)
+            void this.refreshNavigatorImage(z);
+        // Tiled: just move the dims plane — the tiled visual fetches the new slice's tiles (cached per
+        // z), no layer rebuild. Refresh the coarse histogram sample for the new slice.
+        if (this.tiled) {
+            ctx.viewer.dims.z = z;
+            const desc = ctx.tiles.currentDescriptor(ctx.info());
+            if (desc)
+                void this.refreshHistogramSamples(z, desc);
+            this.opts.onSlice?.(false);
+            ctx.tools.scheduleReadback();
+            return;
+        }
+        // Stitch fallback: re-render the slice (re-fetches per-channel / composite). The token lets
+        // render drop a superseded scrub so a slow older slice can't clobber a newer one.
+        const req = ++this.sliceReq;
+        void this.render(z, req)
+            .then(() => {
+            if (req !== this.sliceReq || ctx.signal.aborted)
+                return;
+            // AFTER the image, never before: the render clears the layer list, so whatever sits over
+            // the image is wiped by the very image meant to sit under it.
+            this.opts.onSlice?.(true);
+            ctx.tools.scheduleReadback();
+        })
+            .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));
+    }
+    histogram(channel, bins) {
+        // Tiled mode has no full in-memory pixels → the coarse per-channel sample. RGB: its raw band
+        // (either mode) — never the displayed pixels, which the channel states have recoloured.
+        if (this.tiled || this.imageMode === 'rgb') {
+            const sample = this.histSamples.get(this.imageMode === 'grayscale' ? 0 : channel);
+            return sample ? toIHistogram(histogramScalar(sample, bins, 0, 255)) : null;
+        }
+        // Grayscale/multichannel (stitch): native per-channel histogram straight from the in-memory
+        // scalar layer (no GPU readback).
+        const layer = this.channelView?.layers[this.imageMode === 'grayscale' ? 0 : channel];
+        const h = layer ? this.ctx.viewer.layerHistogram(layer, bins) : null;
+        return h ? toIHistogram(h) : null;
+    }
+    setImageSmoothing(enabled) {
+        // Apply live to the rendered image layers; baked into the next render too.
+        const interpolation = enabled ? 'linear' : 'nearest';
+        this.channelView?.setInterpolation(interpolation);
+        this.bandLayers?.forEach((layer) => (layer.interpolation = interpolation));
+    }
+    setNavigatorVisible(visible) {
+        this.navigator?.setVisible(visible);
+    }
+    /** Show the navigator only for a dataset that brings pixels of its own (and when the user
+     *  wants it): with no image of its own there is nothing for an overview to show. */
+    showNavigatorFor(datasetHasPixels) {
+        this.navigator?.setVisible(datasetHasPixels && this.ctx.settings.navigatorVisible);
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+        this.scaleBar?.dispose();
+        this.scaleBar = null;
+        this.navigator?.dispose();
+        this.navigator = null;
+        this.setNavigatorChannels(null);
+        this.histGen++;
+        this.histSamples.clear();
+        this.channelView = null;
+        this.rgbBands = null;
+        this.bandLayers = null;
+    }
+    /**
+     * Render slice `z`. With a server pyramid descriptor each layer is a pyramidal
+     * {@link TiledSource}, so the view refines to higher resolution on zoom (like OSD) and sits
+     * naturally in full-resolution coordinates; without one, the single-level stitch. Three display
+     * modes either way: multichannel additive tint, grayscale colormap, RGB.
+     */
+    async render(z, token) {
+        const { ctx } = this;
+        const scene = ctx.signal;
+        const desc = await ctx.tiles.ensureDescriptor(ctx.info());
+        // Reset into a newer scene while the descriptor was in flight: this render is superseded.
+        if (scene.aborted)
+            return;
+        if (desc && desc.levels?.length) {
+            if (token != null && token !== this.sliceReq)
+                return;
+            await this.renderTiled(z, desc, scene);
+            return;
+        }
+        return this.renderStitched(z, token);
+    }
+    /** Single-level stitch fallback (no descriptor): the pre-tiling path. */
+    async renderStitched(z, token) {
+        const { ctx } = this;
+        const info = ctx.info();
+        const desc = await ctx.tiles.ensureDescriptor(info);
+        const states = ctx.store.currentChannelStates();
+        // A serverless multichannel stack has no descriptor: its channels are its own plane URLs
+        // (`channelUrls[z][c]`, which fetchChannelData reads), and `urls[z]` only a composite.
+        const serverlessMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);
+        const channelCount = desc?.channels ?? (serverlessMc ? (info?.imageMeta?.[0]?.channelCount ?? 1) : states.length || 1);
+        const multichannel = (!!desc?.multichannel || serverlessMc) && channelCount > 1;
+        // 1) Fetch all pixel data BEFORE touching the viewer, so a superseded scrub can bail without
+        //    having torn down the visible layers (avoids flicker / out-of-order layer state).
+        let mode;
+        let planes = [];
+        let bitmap = null;
+        if (multichannel) {
+            mode = 'multichannel';
+            planes = await Promise.all(Array.from({ length: channelCount }, (_, c) => ctx.tiles.fetchChannelData(info, z, c)));
+        }
+        else if (channelCount === 1) {
+            mode = 'grayscale';
+            // Composite fetch (no channel) → all overview levels usable, so a large grayscale image
+            // selects a fitting downscaled level instead of the full-res real level (texture limit).
+            planes = [await ctx.tiles.fetchChannelData(info, z)];
+        }
+        else {
+            mode = 'rgb';
+            // The bitmap draws the image as it is; its raw bands, the per-band layers and histograms.
+            bitmap = await ctx.tiles.fetchImage(info, z);
+            planes = splitRgbBands(decodeImageRGBA(bitmap));
+        }
+        // 2) Commit — unless a newer scrub superseded us or the scene was torn down.
+        if ((token != null && token !== this.sliceReq) || ctx.signal.aborted) {
+            bitmap?.close?.();
+            return;
+        }
+        // The displayed texture may be a downscaled pyramid level; scale the layer into FULL-RESOLUTION
+        // world coordinates (level-0 pixels) so the camera, readback and — critically — pre-saved
+        // regions (stored in full-res coords, e.g. ndpi) all line up regardless of which level is shown.
+        // This mirrors OSD, whose coordinate system is always level 0.
+        const texW = planes[0]?.width ?? 0;
+        const texH = planes[0]?.height ?? 0;
+        const fullW = desc?.width || texW || 1;
+        const fullH = desc?.height || texH || 1;
+        const scale = [texW ? fullW / texW : 1, texH ? fullH / texH : 1];
+        this.imageMode = mode;
+        const interpolation = ctx.settings.imageSmoothing ? 'linear' : 'nearest';
+        this.channelView = new MultiChannelImageView(ctx.viewer);
+        this.bandLayers = null; // the render clears the layer list, band layers included
+        if (mode === 'multichannel') {
+            const views = planes.map((d, c) => this.tintedChannelView(c, states, desc, typedPlane(d), scale));
+            this.channelView.render('multichannel', views, { interpolation });
+            mergeOntoBlack(this.channelView.layers);
+        }
+        else if (mode === 'grayscale') {
+            const view = this.grayscaleChannelView(states[0], typedPlane(planes[0]), scale);
+            this.channelView.render('grayscale', [view], { interpolation });
+        }
+        else {
+            this.channelView.render('rgb', [{ source: bitmap, scale }], { interpolation });
+            this.rgbBands = { sources: planes.map(typedPlane), scale };
+            this.histSamples.clear();
+            planes.forEach((band, c) => this.histSamples.set(c, band.data));
+            this.syncRgbBands(states);
+        }
+        ctx.setImageSize(fullW, fullH);
+    }
+    /**
+     * Render with pyramidal {@link TiledSource}s — the view refines to higher resolution as you
+     * zoom in (the visual fetches the level whose texels ≈ screen pixels) and sits in full-res
+     * coordinates so regions align. Same three modes as the stitch path. Per-channel layers use the
+     * REAL pyramid levels (per-channel tiles only exist there); the composite uses all levels.
+     */
+    async renderTiled(z, desc, scene) {
+        const { ctx } = this;
+        const states = ctx.store.currentChannelStates();
+        const channelCount = desc.channels ?? (states.length || 1);
+        const multichannel = !!desc.multichannel && channelCount > 1;
+        const interpolation = ctx.settings.imageSmoothing ? 'linear' : 'nearest';
+        this.tiled = true;
+        this.channelView = new MultiChannelImageView(ctx.viewer);
+        if (multichannel) {
+            this.imageMode = 'multichannel';
+            const views = Array.from({ length: channelCount }, (_, c) => this.tintedChannelView(c, states, desc, this.tiledSource(desc, c, 1, scene)));
+            this.channelView.render('multichannel', views, { interpolation });
+            mergeOntoBlack(this.channelView.layers);
+        }
+        else if (channelCount === 1) {
+            this.imageMode = 'grayscale';
+            const view = this.grayscaleChannelView(states[0], this.tiledSource(desc, undefined, 1, scene));
+            this.channelView.render('grayscale', [view], { interpolation });
+        }
+        else {
+            this.imageMode = 'rgb';
+            this.channelView.render('rgb', [{ source: this.tiledSource(desc, undefined, 4, scene) }], {
+                interpolation,
+            });
+            this.rgbBands = {
+                sources: ctx.tiles.rgbBandSources(desc, scene, () => this.ctx.badge.begin('Image')),
+            };
+            this.syncRgbBands(states);
+        }
+        ctx.setImageSize(desc.width, desc.height);
+        // Await on the initial render so getHistogram/autoContrast have data immediately; slice changes
+        // refresh fire-and-forget (the histogram pane retries).
+        await this.refreshHistogramSamples(z, desc);
+    }
+    /** A pyramidal TiledSource whose tiles count on the loading badge while `scene` (the render that
+     *  asked for it, taken before its awaits) is current. */
+    tiledSource(desc, channel, channels, scene) {
+        return this.ctx.tiles.tiledSource(desc, channel, channels, scene, () => this.ctx.badge.begin('Image'));
+    }
+    /** Channel `c`'s layer in the additive multichannel composite: tinted by its display colour
+     *  (store, else descriptor, else the Fiji palette), with its window, gamma and visibility. */
+    tintedChannelView(c, states, desc, source, scale) {
+        const st = states.find((s) => s.index === c);
+        return {
+            source,
+            tint: st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c),
+            name: st?.name ?? `ch${c}`,
+            contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+            visible: st?.visible ?? true,
+            invert: this.ctx.display.invert,
+            ...(scale ? { scale } : {}),
+        };
+    }
+    /** The single grayscale layer: the selected colormap, with the channel's window and gamma. */
+    grayscaleChannelView(st, source, scale) {
+        return {
+            source,
+            colormap: this.ctx.display.grayscaleColormap(),
+            contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+            invert: this.ctx.display.invert,
+            ...(scale ? { scale } : {}),
+        };
+    }
+    /** (Re)fetch a coarse per-channel luminance sample for the histogram (tiled mode has no full
+     *  in-memory pixels). One cheap overview tile per channel, fetched together; cached by channel
+     *  index. Latest wins: a scrub fires one refresh per slice, and an older slice's samples that
+     *  land after a newer one's are dropped rather than shown as the current distribution. */
+    async refreshHistogramSamples(z, desc) {
+        const gen = ++this.histGen;
+        this.histSamples.clear();
+        const info = this.ctx.info();
+        if (this.imageMode === 'rgb') {
+            // One coarse composite tile, split into its raw R, G and B bands.
+            const bands = await this.ctx.tiles.readRgbBands(info, z, 1).catch(() => null);
+            if (gen !== this.histGen || !bands)
+                return;
+            bands.forEach((band, c) => this.histSamples.set(c, band.data));
+            return;
+        }
+        const multichannel = this.imageMode === 'multichannel';
+        const channelCount = multichannel ? (desc.channels ?? 1) : 1;
+        const samples = await Promise.all(Array.from({ length: channelCount }, (_, c) => 
+        // budget 1 → coarsest single tile; a failed channel leaves its sample unset.
+        this.ctx.tiles.fetchChannelData(info, z, multichannel ? c : undefined, 1).then((d) => d.data, () => null)));
+        if (gen !== this.histGen)
+            return;
+        samples.forEach((data, c) => {
+            if (data)
+                this.histSamples.set(c, data);
+        });
+    }
+    /** Channel states + grayscale colormap → live-apply to the rendered layers (no re-fetch; only z
+     *  changes re-fetch), and recolour the navigator thumbnail. */
+    followDisplayState() {
+        this.displaySub = this.ctx.display.watch((channels) => {
+            this.applyDisplayState(channels);
+            this.recolorNavigator();
+        });
+    }
+    /** Apply the current channel states / colormap to the live layers (no re-fetch), delegating the
+     *  per-channel layer mutations to the {@link MultiChannelImageView}. */
+    applyDisplayState(channels) {
+        const view = this.channelView;
+        const { display } = this.ctx;
+        if (!view)
+            return;
+        if (this.imageMode === 'rgb') {
+            this.syncRgbBands(channels);
+        }
+        else if (this.imageMode === 'multichannel') {
+            view.layers.forEach((_, c) => {
+                const st = channels.find((s) => s.index === c);
+                if (!st)
+                    return;
+                view.updateChannel(c, {
+                    tint: st.color,
+                    contrastLimits: [st.min, st.max],
+                    gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ
+                    visible: st.visible,
+                    invert: display.invert,
+                });
+            });
+            mergeOntoBlack(view.layers);
+        }
+        else if (this.imageMode === 'grayscale') {
+            const st = channels[0];
+            view.updateChannel(0, {
+                colormap: display.grayscaleColormap(),
+                invert: display.invert,
+                ...(st ? { contrastLimits: [st.min, st.max], gamma: toNapariGamma(st.gamma) } : {}),
+            });
+        }
+    }
+    /**
+     * RGB: draw the image as it is while its channel states leave it so (default R/G/B tints, full
+     * window, γ 1, all shown, no invert: {@link rgbNeedsRecolor}) — the RGB layer, unchanged, with
+     * the coarse underlay a tiled one keeps while it pans. Otherwise draw its R, G and B bands as
+     * three additive layers, each with its channel's window, invert, gamma, tint and visibility —
+     * what OSD's RGB recolour computes per pixel (the merge order of `osd/display-pipeline`). The
+     * band layers sit just above the hidden RGB layer, so whatever is drawn over the image stays
+     * over it. A host with no R/G/B channel model (fewer than three states) gets only the invert.
+     */
+    syncRgbBands(channels) {
+        const { viewer, display } = this.ctx;
+        const rgb = this.channelView?.layers[0];
+        const bands = this.rgbBands;
+        if (!rgb || !bands)
+            return;
+        const states = channels.length >= 3 ? channels : [];
+        if (!rgbNeedsRecolor(states, display.invert)) {
+            this.bandLayers?.forEach((layer) => viewer.layers.remove(layer));
+            this.bandLayers = null;
+            rgb.visible = true;
+            viewer.requestRender();
+            return;
+        }
+        if (!this.bandLayers) {
+            const at = viewer.layers.items.indexOf(rgb);
+            this.bandLayers = bands.sources.map((source, c) => {
+                const layer = viewer.addImage(source, {
+                    name: `rgb${c}`,
+                    blending: 'additive',
+                    interpolation: rgb.interpolation,
+                    ...(bands.scale ? { scale: bands.scale } : {}),
+                });
+                viewer.layers.move(layer, at + 1 + c);
+                return layer;
+            });
+            rgb.visible = false;
+        }
+        this.bandLayers.forEach((layer, c) => {
+            const st = states.find((s) => s.index === c);
+            layer.colormap = tintColormap(st?.color ?? tintFor(c));
+            layer.contrastLimits = [st?.min ?? 0, st?.max ?? 255];
+            layer.gamma = toNapariGamma(st?.gamma); // ImageJ γ → napari-js γ
+            layer.visible = st?.visible ?? true;
+            layer.invert = display.invert;
+        });
+        mergeOntoBlack(this.bandLayers);
+        viewer.requestRender();
+    }
+    /** (Re)install the physical scale bar (napari-js's `ScaleBarOverlay` on the 2D camera's zoom),
+     *  sized from the image's µm/pixel (`/tiles/info` mppX, falling back to the image metadata).
+     *  No-op without a physical size. */
+    installScaleBar() {
+        const { ctx } = this;
+        this.scaleBar?.dispose();
+        this.scaleBar = null;
+        const mppX = ctx.tiles.mppX(ctx.info());
+        if (mppX > 0)
+            this.scaleBar = new ScaleBarOverlay(ctx.host, ctx.viewer, { unitPerWorld: mppX, mode: '2d' });
+    }
+    /**
+     * The overview navigator (napari-js's `NavigatorOverlay`): a coarse thumbnail of the whole
+     * image with the viewport on it; click or drag to pan at the current zoom (as OSD).
+     */
+    installNavigator(z) {
+        const { ctx } = this;
+        this.navigator?.dispose();
+        this.navigator = null;
+        const { width, height } = ctx.imageSize();
+        if (!width || !height)
+            return;
+        this.navigator = new NavigatorOverlay(ctx.host, ctx.viewer, {
+            worldWidth: width,
+            worldHeight: height,
+            onEnter: () => this.opts.onNavigatorInteract?.(),
+            visible: ctx.settings.navigatorVisible,
+        });
+        void this.refreshNavigatorImage(z);
+    }
+    /**
+     * Draw the navigator's thumbnail from the coarsest pyramid level. A multichannel image
+     * is composited from its channels in their display colours (see {@link recolorNavigator}),
+     * so the overview looks like the view rather than like channel 0 in grey.
+     */
+    async refreshNavigatorImage(z) {
+        const nav = this.navigator;
+        if (!nav)
+            return;
+        const token = ++this.navigatorToken;
+        const { tiles } = this.ctx;
+        const info = this.ctx.info();
+        try {
+            const desc = await tiles.ensureDescriptor(info);
+            // Superseded (a newer slice, or the scene was torn down): fetch nothing.
+            if (token !== this.navigatorToken || this.navigator !== nav)
+                return;
+            // A serverless multichannel stack's thumbnails are its own channel planes.
+            const count = desc?.multichannel
+                ? (desc.channelInfo?.length ?? 0)
+                : isServerlessMultichannel(tiles.isSimple(info), info)
+                    ? (info?.imageMeta?.[0]?.channelCount ?? 0)
+                    : 0;
+            if (count > 1) {
+                const bitmaps = await Promise.all(Array.from({ length: count }, (_c, c) => tiles.overviewImage(info, z, c)));
+                if (token !== this.navigatorToken || this.navigator !== nav)
+                    return;
+                this.setNavigatorChannels(bitmaps);
+                this.recolorNavigator();
+            }
+            else {
+                const image = await tiles.overviewImage(info, z);
+                if (token !== this.navigatorToken || this.navigator !== nav)
+                    return;
+                this.setNavigatorChannels(null);
+                nav.setImage(image);
+            }
+        }
+        catch (err) {
+            console.warn('[napari-js] navigator thumbnail unavailable', err);
+        }
+    }
+    /** Replace the per-channel thumbnail bitmaps (closing the previous ones). */
+    setNavigatorChannels(bitmaps) {
+        for (const bmp of this.navigatorChannels ?? [])
+            if ('close' in bmp)
+                bmp.close?.();
+        this.navigatorChannels = bitmaps;
+        this.navigatorTintKey = '';
+    }
+    /**
+     * Composite the multichannel thumbnail in the channels' CURRENT display tints, skipping hidden
+     * channels — the store's channel states, as the 2D layers use, not the server's defaults.
+     * Re-run on every display-state change; it only redraws (never re-fetches), and only when a
+     * tint or a visibility actually changed, so a window/gamma drag costs a string compare.
+     */
+    recolorNavigator() {
+        const nav = this.navigator;
+        const bitmaps = this.navigatorChannels;
+        if (!nav || !bitmaps)
+            return;
+        const info = this.ctx.tiles.currentDescriptor(this.ctx.info())?.channelInfo;
+        const states = this.ctx.store.currentChannelStates();
+        const shown = bitmaps
+            .map((bmp, c) => {
+            const st = states.find((s) => s.index === c);
+            return { bmp, visible: st?.visible ?? true, color: st?.color ?? info?.[c]?.color ?? tintFor(c) };
+        })
+            .filter((ch) => ch.visible);
+        const key = shown.map((ch) => `${bitmaps.indexOf(ch.bmp)}:${ch.color}`).join('|');
+        if (key === this.navigatorTintKey)
+            return;
+        this.navigatorTintKey = key;
+        nav.setImage(tintedComposite(shown.map((ch) => ch.bmp), shown.map((ch) => ch.color)));
+    }
+}
+/**
+ * NAPARI_SCATTER (review Appendix B, cluster H): the slice image with a points layer at each
+ * region's centroid (the napari-js analog of Plotly's region-centroid scatter), rebuilt live as
+ * regions change. This mode plots REGION centroids, so the image's region tools come with it —
+ * drawing a region adds a point at once.
+ */
+export class ScatterRegionsScene {
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.points = null;
+        this.regionSub = null;
+        this.image = new Image2dScene(ctx, {
+            // The region-centroid points went with the re-render's layer clear.
+            onSlice: (rerendered) => {
+                if (rerendered && this.points)
+                    this.rebuildPoints();
+            },
+        });
+    }
+    async mount() {
+        await this.image.mount();
+        // Disposed while the image loaded: a subscription now would outlive the scene.
+        if (this.ctx.signal.aborted)
+            return;
+        this.rebuildPoints();
+        this.regionSub = this.ctx.regionStore.getRegionUpdateEvent().subscribe(() => this.rebuildPoints());
+        this.ctx.tools.scheduleReadback();
+    }
+    setZ(z) {
+        this.image.setZ(z);
+    }
+    histogram(channel, bins) {
+        return this.image.histogram(channel, bins);
+    }
+    setImageSmoothing(enabled) {
+        this.image.setImageSmoothing(enabled);
+    }
+    setNavigatorVisible(visible) {
+        this.image.setNavigatorVisible(visible);
+    }
+    dispose() {
+        this.regionSub?.unsubscribe();
+        this.regionSub = null;
+        this.image.dispose();
+    }
+    /** (Re)build the point layer at the current region centroids. */
+    rebuildPoints() {
+        const v = this.ctx.viewer;
+        if (this.points) {
+            v.layers.remove(this.points);
+            this.points = null;
+        }
+        const centroids = regionCentroids(this.ctx.regionStore.getRegions());
+        if (centroids.length === 0)
+            return;
+        this.points = v.addPoints(centroids, {
+            size: 12,
+            faceColor: [1, 0.85, 0.2, 1],
+            borderColor: [0, 0, 0, 1],
+            borderWidth: 2,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-image-2d-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-image-2d-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\nimport { MultiChannelImageView, decodeImageRGBA, histogramScalar, tintColormap } from 'napari-js';\nimport type { ChannelView, ImageLayer, PointsLayer, TiledSource } from 'napari-js';\nimport { NavigatorOverlay, ScaleBarOverlay } from 'napari-js/overlays';\n\nimport { IChannelState, IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { TileDescriptor } from '../tile-server';\nimport { rgbNeedsRecolor } from '../osd/display-pipeline';\nimport type { OverviewImage } from './napari-tile-client';\nimport { regionCentroids } from '../region-centroids';\nimport {\n  LumaPlane,\n  isServerlessMultichannel,\n  splitRgbBands,\n  tintFor,\n  tintedComposite,\n  toIHistogram,\n  toNapariGamma,\n  typedPlane,\n} from './napari-helpers';\nimport type { NapariScene, SceneContext } from './napari-scene';\n\n/** What the scenes built over the 2D image add to it. */\nexport interface Image2dOptions {\n  /** Draw the loaded image (false: an image-less spatial dataset, the observations alone). */\n  image?: boolean;\n  /** Whether to fit the camera to the image once it is drawn (default: when there is one). */\n  fit?: () => boolean;\n  /** After a slice change. `rerendered` when the stitched path re-rendered the image — which\n   *  CLEARS the layer list, taking every other layer with it. */\n  onSlice?: (rerendered: boolean) => void;\n  /** The pointer entered the navigator (e.g. to hide a hover tooltip over the canvas). */\n  onNavigatorInteract?: () => void;\n}\n\n/**\n * Composite additive channel layers onto black, as OSD and Plotly merge them: the bottom-most\n * SHOWN layer replaces what is under it, the others add onto it. All-additive layers added onto\n * the viewer's dark-grey background instead, lifting every black pixel to that grey.\n */\nfunction mergeOntoBlack(layers: readonly ImageLayer[]): void {\n  const base = layers.find((layer) => layer.visible);\n  for (const layer of layers) layer.blending = layer === base ? 'translucent' : 'additive';\n}\n\n/**\n * The 2D image (review Appendix B, cluster E): pyramidal `TiledSource`s against the `/tile`\n * endpoint when `/tiles/info` describes the image, else a single stitched level (`tiled:false`\n * stacks fetch each slice's own URL, a serverless multichannel stack each channel's own plane);\n * multichannel additive tints, grayscale colormap or RGB (recoloured per band, see\n * {@link syncRgbBands}); the coarse histogram samples of the tiled path, the scale bar, the\n * overview navigator and the 2D interaction stack (region overlay + pixel tools). The\n * region-centroid scatter and the spatial 2D scene are built over it.\n */\nexport class Image2dScene implements NapariScene {\n  /** How the image is composited (drives the histogram and the display-state updates). */\n  imageMode: 'grayscale' | 'multichannel' | 'rgb' = 'rgb';\n  /** True when the image is rendered via pyramidal TiledSources (descriptor available). */\n  tiled = false;\n  /** napari-js high-level view owning the per-channel layer set for {@link imageMode}. */\n  private channelView: MultiChannelImageView | null = null;\n  /** Latest wins for a stitched slice: a slow older slice can't clobber a newer one. */\n  private sliceReq = 0;\n  /** RGB: the R, G and B bands as layer sources (typed planes, or band `TiledSource`s that share\n   *  one request per tile) and the stitched level's scale — what {@link syncRgbBands} draws. */\n  private rgbBands: { sources: ChannelView['source'][]; scale?: [number, number] } | null = null;\n  /** RGB: the three additive band layers while the channel states recolour the image; null while\n   *  the RGB layer draws it as it is. */\n  private bandLayers: ImageLayer[] | null = null;\n  /** Coarse per-channel luminance sample (keyed by channel index) for the histogram in tiled mode,\n   *  where the layers have no full in-memory pixels — and an RGB image's raw bands in either mode.\n   *  Refreshed on mount + slice change. */\n  readonly histSamples = new Map<number, Uint8Array>();\n  /** Latest-wins token for {@link refreshHistogramSamples}. */\n  private histGen = 0;\n  /** Physical scale bar overlay (null when the image has no µm/pixel). */\n  private scaleBar: ScaleBarOverlay | null = null;\n  /** Overview minimap (bottom-right), as OSD's navigator. */\n  private navigator: NavigatorOverlay | null = null;\n  /** Bumped per thumbnail request, so a slow one cannot overwrite a newer slice's. */\n  private navigatorToken = 0;\n  /** The current slice's per-channel thumbnail bitmaps (multichannel only), kept so a tint or\n   *  visibility change recolours the thumbnail without re-fetching it. */\n  private navigatorChannels: OverviewImage[] | null = null;\n  /** The tints/visibility the thumbnail was last composited with — see {@link recolorNavigator}. */\n  private navigatorTintKey = '';\n  private displaySub: Subscription | null = null;\n\n  constructor(\n    private readonly ctx: SceneContext,\n    private readonly opts: Image2dOptions = {},\n  ) {}\n\n  private get hasImage(): boolean {\n    return this.opts.image !== false;\n  }\n\n  async mount(): Promise<void> {\n    const { ctx } = this;\n    const z = ctx.z();\n    if (this.hasImage) await this.render(z);\n    // Reset into a newer scene while the image loaded: this scene is already disposed, and the\n    // tool bridge is the next scene's — install nothing more.\n    if (ctx.signal.aborted) return;\n    if (this.opts.fit ? this.opts.fit() : this.hasImage) ctx.fitCameraSoon();\n    this.followDisplayState();\n    // The scale bar and navigator describe an image; with none loaded, whatever they would\n    // read is left over from the last one.\n    if (this.hasImage) {\n      this.installScaleBar();\n      this.installNavigator(z);\n    }\n    ctx.tools.install2dInteraction(ctx.viewer, ctx.host);\n  }\n\n  setZ(z: number): void {\n    const { ctx } = this;\n    if (this.navigator) void this.refreshNavigatorImage(z);\n    // Tiled: just move the dims plane — the tiled visual fetches the new slice's tiles (cached per\n    // z), no layer rebuild. Refresh the coarse histogram sample for the new slice.\n    if (this.tiled) {\n      ctx.viewer.dims.z = z;\n      const desc = ctx.tiles.currentDescriptor(ctx.info());\n      if (desc) void this.refreshHistogramSamples(z, desc);\n      this.opts.onSlice?.(false);\n      ctx.tools.scheduleReadback();\n      return;\n    }\n    // Stitch fallback: re-render the slice (re-fetches per-channel / composite). The token lets\n    // render drop a superseded scrub so a slow older slice can't clobber a newer one.\n    const req = ++this.sliceReq;\n    void this.render(z, req)\n      .then(() => {\n        if (req !== this.sliceReq || ctx.signal.aborted) return;\n        // AFTER the image, never before: the render clears the layer list, so whatever sits over\n        // the image is wiped by the very image meant to sit under it.\n        this.opts.onSlice?.(true);\n        ctx.tools.scheduleReadback();\n      })\n      .catch((err) => console.error('[napari-js] setZIndex slice failed:', err));\n  }\n\n  histogram(channel: number, bins: number): IHistogram | null {\n    // Tiled mode has no full in-memory pixels → the coarse per-channel sample. RGB: its raw band\n    // (either mode) — never the displayed pixels, which the channel states have recoloured.\n    if (this.tiled || this.imageMode === 'rgb') {\n      const sample = this.histSamples.get(this.imageMode === 'grayscale' ? 0 : channel);\n      return sample ? toIHistogram(histogramScalar(sample, bins, 0, 255)) : null;\n    }\n    // Grayscale/multichannel (stitch): native per-channel histogram straight from the in-memory\n    // scalar layer (no GPU readback).\n    const layer = this.channelView?.layers[this.imageMode === 'grayscale' ? 0 : channel];\n    const h = layer ? this.ctx.viewer.layerHistogram(layer, bins) : null;\n    return h ? toIHistogram(h) : null;\n  }\n\n  setImageSmoothing(enabled: boolean): void {\n    // Apply live to the rendered image layers; baked into the next render too.\n    const interpolation = enabled ? 'linear' : 'nearest';\n    this.channelView?.setInterpolation(interpolation);\n    this.bandLayers?.forEach((layer) => (layer.interpolation = interpolation));\n  }\n\n  setNavigatorVisible(visible: boolean): void {\n    this.navigator?.setVisible(visible);\n  }\n\n  /** Show the navigator only for a dataset that brings pixels of its own (and when the user\n   *  wants it): with no image of its own there is nothing for an overview to show. */\n  showNavigatorFor(datasetHasPixels: boolean): void {\n    this.navigator?.setVisible(datasetHasPixels && this.ctx.settings.navigatorVisible);\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.scaleBar?.dispose();\n    this.scaleBar = null;\n    this.navigator?.dispose();\n    this.navigator = null;\n    this.setNavigatorChannels(null);\n    this.histGen++;\n    this.histSamples.clear();\n    this.channelView = null;\n    this.rgbBands = null;\n    this.bandLayers = null;\n  }\n\n  /**\n   * Render slice `z`. With a server pyramid descriptor each layer is a pyramidal\n   * {@link TiledSource}, so the view refines to higher resolution on zoom (like OSD) and sits\n   * naturally in full-resolution coordinates; without one, the single-level stitch. Three display\n   * modes either way: multichannel additive tint, grayscale colormap, RGB.\n   */\n  async render(z: number, token?: number): Promise<void> {\n    const { ctx } = this;\n    const scene = ctx.signal;\n    const desc = await ctx.tiles.ensureDescriptor(ctx.info());\n    // Reset into a newer scene while the descriptor was in flight: this render is superseded.\n    if (scene.aborted) return;\n    if (desc && desc.levels?.length) {\n      if (token != null && token !== this.sliceReq) return;\n      await this.renderTiled(z, desc, scene);\n      return;\n    }\n    return this.renderStitched(z, token);\n  }\n\n  /** Single-level stitch fallback (no descriptor): the pre-tiling path. */\n  private async renderStitched(z: number, token?: number): Promise<void> {\n    const { ctx } = this;\n    const info = ctx.info();\n    const desc = await ctx.tiles.ensureDescriptor(info);\n    const states = ctx.store.currentChannelStates();\n    // A serverless multichannel stack has no descriptor: its channels are its own plane URLs\n    // (`channelUrls[z][c]`, which fetchChannelData reads), and `urls[z]` only a composite.\n    const serverlessMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);\n    const channelCount =\n      desc?.channels ?? (serverlessMc ? (info?.imageMeta?.[0]?.channelCount ?? 1) : states.length || 1);\n    const multichannel = (!!desc?.multichannel || serverlessMc) && channelCount > 1;\n\n    // 1) Fetch all pixel data BEFORE touching the viewer, so a superseded scrub can bail without\n    //    having torn down the visible layers (avoids flicker / out-of-order layer state).\n    let mode: 'grayscale' | 'multichannel' | 'rgb';\n    let planes: LumaPlane[] = [];\n    let bitmap: ImageBitmap | null = null;\n    if (multichannel) {\n      mode = 'multichannel';\n      planes = await Promise.all(\n        Array.from({ length: channelCount }, (_, c) => ctx.tiles.fetchChannelData(info, z, c)),\n      );\n    } else if (channelCount === 1) {\n      mode = 'grayscale';\n      // Composite fetch (no channel) → all overview levels usable, so a large grayscale image\n      // selects a fitting downscaled level instead of the full-res real level (texture limit).\n      planes = [await ctx.tiles.fetchChannelData(info, z)];\n    } else {\n      mode = 'rgb';\n      // The bitmap draws the image as it is; its raw bands, the per-band layers and histograms.\n      bitmap = await ctx.tiles.fetchImage(info, z);\n      planes = splitRgbBands(decodeImageRGBA(bitmap));\n    }\n\n    // 2) Commit — unless a newer scrub superseded us or the scene was torn down.\n    if ((token != null && token !== this.sliceReq) || ctx.signal.aborted) {\n      bitmap?.close?.();\n      return;\n    }\n\n    // The displayed texture may be a downscaled pyramid level; scale the layer into FULL-RESOLUTION\n    // world coordinates (level-0 pixels) so the camera, readback and — critically — pre-saved\n    // regions (stored in full-res coords, e.g. ndpi) all line up regardless of which level is shown.\n    // This mirrors OSD, whose coordinate system is always level 0.\n    const texW = planes[0]?.width ?? 0;\n    const texH = planes[0]?.height ?? 0;\n    const fullW = desc?.width || texW || 1;\n    const fullH = desc?.height || texH || 1;\n    const scale: [number, number] = [texW ? fullW / texW : 1, texH ? fullH / texH : 1];\n\n    this.imageMode = mode;\n    const interpolation: 'linear' | 'nearest' = ctx.settings.imageSmoothing ? 'linear' : 'nearest';\n    this.channelView = new MultiChannelImageView(ctx.viewer);\n    this.bandLayers = null; // the render clears the layer list, band layers included\n    if (mode === 'multichannel') {\n      const views = planes.map((d, c) => this.tintedChannelView(c, states, desc, typedPlane(d), scale));\n      this.channelView.render('multichannel', views, { interpolation });\n      mergeOntoBlack(this.channelView.layers);\n    } else if (mode === 'grayscale') {\n      const view = this.grayscaleChannelView(states[0], typedPlane(planes[0]), scale);\n      this.channelView.render('grayscale', [view], { interpolation });\n    } else {\n      this.channelView.render('rgb', [{ source: bitmap as ImageBitmap, scale }], { interpolation });\n      this.rgbBands = { sources: planes.map(typedPlane), scale };\n      this.histSamples.clear();\n      planes.forEach((band, c) => this.histSamples.set(c, band.data));\n      this.syncRgbBands(states);\n    }\n    ctx.setImageSize(fullW, fullH);\n  }\n\n  /**\n   * Render with pyramidal {@link TiledSource}s — the view refines to higher resolution as you\n   * zoom in (the visual fetches the level whose texels ≈ screen pixels) and sits in full-res\n   * coordinates so regions align. Same three modes as the stitch path. Per-channel layers use the\n   * REAL pyramid levels (per-channel tiles only exist there); the composite uses all levels.\n   */\n  private async renderTiled(z: number, desc: TileDescriptor, scene: AbortSignal): Promise<void> {\n    const { ctx } = this;\n    const states = ctx.store.currentChannelStates();\n    const channelCount = desc.channels ?? (states.length || 1);\n    const multichannel = !!desc.multichannel && channelCount > 1;\n    const interpolation: 'linear' | 'nearest' = ctx.settings.imageSmoothing ? 'linear' : 'nearest';\n\n    this.tiled = true;\n    this.channelView = new MultiChannelImageView(ctx.viewer);\n\n    if (multichannel) {\n      this.imageMode = 'multichannel';\n      const views = Array.from({ length: channelCount }, (_, c) =>\n        this.tintedChannelView(c, states, desc, this.tiledSource(desc, c, 1, scene)),\n      );\n      this.channelView.render('multichannel', views, { interpolation });\n      mergeOntoBlack(this.channelView.layers);\n    } else if (channelCount === 1) {\n      this.imageMode = 'grayscale';\n      const view = this.grayscaleChannelView(states[0], this.tiledSource(desc, undefined, 1, scene));\n      this.channelView.render('grayscale', [view], { interpolation });\n    } else {\n      this.imageMode = 'rgb';\n      this.channelView.render('rgb', [{ source: this.tiledSource(desc, undefined, 4, scene) }], {\n        interpolation,\n      });\n      this.rgbBands = {\n        sources: ctx.tiles.rgbBandSources(desc, scene, () => this.ctx.badge.begin('Image')),\n      };\n      this.syncRgbBands(states);\n    }\n    ctx.setImageSize(desc.width, desc.height);\n    // Await on the initial render so getHistogram/autoContrast have data immediately; slice changes\n    // refresh fire-and-forget (the histogram pane retries).\n    await this.refreshHistogramSamples(z, desc);\n  }\n\n  /** A pyramidal TiledSource whose tiles count on the loading badge while `scene` (the render that\n   *  asked for it, taken before its awaits) is current. */\n  tiledSource(\n    desc: TileDescriptor,\n    channel: number | undefined,\n    channels: 1 | 4,\n    scene: AbortSignal,\n  ): TiledSource {\n    return this.ctx.tiles.tiledSource(desc, channel, channels, scene, () => this.ctx.badge.begin('Image'));\n  }\n\n  /** Channel `c`'s layer in the additive multichannel composite: tinted by its display colour\n   *  (store, else descriptor, else the Fiji palette), with its window, gamma and visibility. */\n  private tintedChannelView(\n    c: number,\n    states: IChannelState[],\n    desc: TileDescriptor | null,\n    source: ChannelView['source'],\n    scale?: [number, number],\n  ): ChannelView {\n    const st = states.find((s) => s.index === c);\n    return {\n      source,\n      tint: st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c),\n      name: st?.name ?? `ch${c}`,\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n      visible: st?.visible ?? true,\n      invert: this.ctx.display.invert,\n      ...(scale ? { scale } : {}),\n    };\n  }\n\n  /** The single grayscale layer: the selected colormap, with the channel's window and gamma. */\n  private grayscaleChannelView(\n    st: IChannelState | undefined,\n    source: ChannelView['source'],\n    scale?: [number, number],\n  ): ChannelView {\n    return {\n      source,\n      colormap: this.ctx.display.grayscaleColormap(),\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n      invert: this.ctx.display.invert,\n      ...(scale ? { scale } : {}),\n    };\n  }\n\n  /** (Re)fetch a coarse per-channel luminance sample for the histogram (tiled mode has no full\n   *  in-memory pixels). One cheap overview tile per channel, fetched together; cached by channel\n   *  index. Latest wins: a scrub fires one refresh per slice, and an older slice's samples that\n   *  land after a newer one's are dropped rather than shown as the current distribution. */\n  async refreshHistogramSamples(z: number, desc: Pick<TileDescriptor, 'channels'>): Promise<void> {\n    const gen = ++this.histGen;\n    this.histSamples.clear();\n    const info = this.ctx.info();\n    if (this.imageMode === 'rgb') {\n      // One coarse composite tile, split into its raw R, G and B bands.\n      const bands = await this.ctx.tiles.readRgbBands(info, z, 1).catch(() => null);\n      if (gen !== this.histGen || !bands) return;\n      bands.forEach((band, c) => this.histSamples.set(c, band.data));\n      return;\n    }\n    const multichannel = this.imageMode === 'multichannel';\n    const channelCount = multichannel ? (desc.channels ?? 1) : 1;\n    const samples = await Promise.all(\n      Array.from({ length: channelCount }, (_, c) =>\n        // budget 1 → coarsest single tile; a failed channel leaves its sample unset.\n        this.ctx.tiles.fetchChannelData(info, z, multichannel ? c : undefined, 1).then(\n          (d) => d.data,\n          () => null,\n        ),\n      ),\n    );\n    if (gen !== this.histGen) return;\n    samples.forEach((data, c) => {\n      if (data) this.histSamples.set(c, data);\n    });\n  }\n\n  /** Channel states + grayscale colormap → live-apply to the rendered layers (no re-fetch; only z\n   *  changes re-fetch), and recolour the navigator thumbnail. */\n  private followDisplayState(): void {\n    this.displaySub = this.ctx.display.watch((channels) => {\n      this.applyDisplayState(channels);\n      this.recolorNavigator();\n    });\n  }\n\n  /** Apply the current channel states / colormap to the live layers (no re-fetch), delegating the\n   *  per-channel layer mutations to the {@link MultiChannelImageView}. */\n  private applyDisplayState(channels: IChannelState[]): void {\n    const view = this.channelView;\n    const { display } = this.ctx;\n    if (!view) return;\n    if (this.imageMode === 'rgb') {\n      this.syncRgbBands(channels);\n    } else if (this.imageMode === 'multichannel') {\n      view.layers.forEach((_, c) => {\n        const st = channels.find((s) => s.index === c);\n        if (!st) return;\n        view.updateChannel(c, {\n          tint: st.color,\n          contrastLimits: [st.min, st.max],\n          gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ\n          visible: st.visible,\n          invert: display.invert,\n        });\n      });\n      mergeOntoBlack(view.layers);\n    } else if (this.imageMode === 'grayscale') {\n      const st = channels[0];\n      view.updateChannel(0, {\n        colormap: display.grayscaleColormap(),\n        invert: display.invert,\n        ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: toNapariGamma(st.gamma) } : {}),\n      });\n    }\n  }\n\n  /**\n   * RGB: draw the image as it is while its channel states leave it so (default R/G/B tints, full\n   * window, γ 1, all shown, no invert: {@link rgbNeedsRecolor}) — the RGB layer, unchanged, with\n   * the coarse underlay a tiled one keeps while it pans. Otherwise draw its R, G and B bands as\n   * three additive layers, each with its channel's window, invert, gamma, tint and visibility —\n   * what OSD's RGB recolour computes per pixel (the merge order of `osd/display-pipeline`). The\n   * band layers sit just above the hidden RGB layer, so whatever is drawn over the image stays\n   * over it. A host with no R/G/B channel model (fewer than three states) gets only the invert.\n   */\n  private syncRgbBands(channels: IChannelState[]): void {\n    const { viewer, display } = this.ctx;\n    const rgb = this.channelView?.layers[0];\n    const bands = this.rgbBands;\n    if (!rgb || !bands) return;\n    const states = channels.length >= 3 ? channels : [];\n    if (!rgbNeedsRecolor(states, display.invert)) {\n      this.bandLayers?.forEach((layer) => viewer.layers.remove(layer));\n      this.bandLayers = null;\n      rgb.visible = true;\n      viewer.requestRender();\n      return;\n    }\n    if (!this.bandLayers) {\n      const at = viewer.layers.items.indexOf(rgb);\n      this.bandLayers = bands.sources.map((source, c) => {\n        const layer = viewer.addImage(source, {\n          name: `rgb${c}`,\n          blending: 'additive',\n          interpolation: rgb.interpolation,\n          ...(bands.scale ? { scale: bands.scale } : {}),\n        });\n        viewer.layers.move(layer, at + 1 + c);\n        return layer;\n      });\n      rgb.visible = false;\n    }\n    this.bandLayers.forEach((layer, c) => {\n      const st = states.find((s) => s.index === c);\n      layer.colormap = tintColormap(st?.color ?? tintFor(c));\n      layer.contrastLimits = [st?.min ?? 0, st?.max ?? 255];\n      layer.gamma = toNapariGamma(st?.gamma); // ImageJ γ → napari-js γ\n      layer.visible = st?.visible ?? true;\n      layer.invert = display.invert;\n    });\n    mergeOntoBlack(this.bandLayers);\n    viewer.requestRender();\n  }\n\n  /** (Re)install the physical scale bar (napari-js's `ScaleBarOverlay` on the 2D camera's zoom),\n   *  sized from the image's µm/pixel (`/tiles/info` mppX, falling back to the image metadata).\n   *  No-op without a physical size. */\n  installScaleBar(): void {\n    const { ctx } = this;\n    this.scaleBar?.dispose();\n    this.scaleBar = null;\n    const mppX = ctx.tiles.mppX(ctx.info());\n    if (mppX > 0) this.scaleBar = new ScaleBarOverlay(ctx.host, ctx.viewer, { unitPerWorld: mppX, mode: '2d' });\n  }\n\n  /**\n   * The overview navigator (napari-js's `NavigatorOverlay`): a coarse thumbnail of the whole\n   * image with the viewport on it; click or drag to pan at the current zoom (as OSD).\n   */\n  private installNavigator(z: number): void {\n    const { ctx } = this;\n    this.navigator?.dispose();\n    this.navigator = null;\n    const { width, height } = ctx.imageSize();\n    if (!width || !height) return;\n    this.navigator = new NavigatorOverlay(ctx.host, ctx.viewer, {\n      worldWidth: width,\n      worldHeight: height,\n      onEnter: () => this.opts.onNavigatorInteract?.(),\n      visible: ctx.settings.navigatorVisible,\n    });\n    void this.refreshNavigatorImage(z);\n  }\n\n  /**\n   * Draw the navigator's thumbnail from the coarsest pyramid level. A multichannel image\n   * is composited from its channels in their display colours (see {@link recolorNavigator}),\n   * so the overview looks like the view rather than like channel 0 in grey.\n   */\n  private async refreshNavigatorImage(z: number): Promise<void> {\n    const nav = this.navigator;\n    if (!nav) return;\n    const token = ++this.navigatorToken;\n    const { tiles } = this.ctx;\n    const info = this.ctx.info();\n    try {\n      const desc = await tiles.ensureDescriptor(info);\n      // Superseded (a newer slice, or the scene was torn down): fetch nothing.\n      if (token !== this.navigatorToken || this.navigator !== nav) return;\n      // A serverless multichannel stack's thumbnails are its own channel planes.\n      const count = desc?.multichannel\n        ? (desc.channelInfo?.length ?? 0)\n        : isServerlessMultichannel(tiles.isSimple(info), info)\n          ? (info?.imageMeta?.[0]?.channelCount ?? 0)\n          : 0;\n      if (count > 1) {\n        const bitmaps = await Promise.all(\n          Array.from({ length: count }, (_c, c) => tiles.overviewImage(info, z, c)),\n        );\n        if (token !== this.navigatorToken || this.navigator !== nav) return;\n        this.setNavigatorChannels(bitmaps);\n        this.recolorNavigator();\n      } else {\n        const image = await tiles.overviewImage(info, z);\n        if (token !== this.navigatorToken || this.navigator !== nav) return;\n        this.setNavigatorChannels(null);\n        nav.setImage(image);\n      }\n    } catch (err) {\n      console.warn('[napari-js] navigator thumbnail unavailable', err);\n    }\n  }\n\n  /** Replace the per-channel thumbnail bitmaps (closing the previous ones). */\n  private setNavigatorChannels(bitmaps: OverviewImage[] | null): void {\n    for (const bmp of this.navigatorChannels ?? []) if ('close' in bmp) bmp.close?.();\n    this.navigatorChannels = bitmaps;\n    this.navigatorTintKey = '';\n  }\n\n  /**\n   * Composite the multichannel thumbnail in the channels' CURRENT display tints, skipping hidden\n   * channels — the store's channel states, as the 2D layers use, not the server's defaults.\n   * Re-run on every display-state change; it only redraws (never re-fetches), and only when a\n   * tint or a visibility actually changed, so a window/gamma drag costs a string compare.\n   */\n  private recolorNavigator(): void {\n    const nav = this.navigator;\n    const bitmaps = this.navigatorChannels;\n    if (!nav || !bitmaps) return;\n    const info = this.ctx.tiles.currentDescriptor(this.ctx.info())?.channelInfo;\n    const states = this.ctx.store.currentChannelStates();\n    const shown = bitmaps\n      .map((bmp, c) => {\n        const st = states.find((s) => s.index === c);\n        return { bmp, visible: st?.visible ?? true, color: st?.color ?? info?.[c]?.color ?? tintFor(c) };\n      })\n      .filter((ch) => ch.visible);\n    const key = shown.map((ch) => `${bitmaps.indexOf(ch.bmp)}:${ch.color}`).join('|');\n    if (key === this.navigatorTintKey) return;\n    this.navigatorTintKey = key;\n    nav.setImage(\n      tintedComposite(\n        shown.map((ch) => ch.bmp),\n        shown.map((ch) => ch.color),\n      ),\n    );\n  }\n}\n\n/**\n * NAPARI_SCATTER (review Appendix B, cluster H): the slice image with a points layer at each\n * region's centroid (the napari-js analog of Plotly's region-centroid scatter), rebuilt live as\n * regions change. This mode plots REGION centroids, so the image's region tools come with it —\n * drawing a region adds a point at once.\n */\nexport class ScatterRegionsScene implements NapariScene {\n  readonly image: Image2dScene;\n  private points: PointsLayer | null = null;\n  private regionSub: Subscription | null = null;\n\n  constructor(private readonly ctx: SceneContext) {\n    this.image = new Image2dScene(ctx, {\n      // The region-centroid points went with the re-render's layer clear.\n      onSlice: (rerendered) => {\n        if (rerendered && this.points) this.rebuildPoints();\n      },\n    });\n  }\n\n  async mount(): Promise<void> {\n    await this.image.mount();\n    // Disposed while the image loaded: a subscription now would outlive the scene.\n    if (this.ctx.signal.aborted) return;\n    this.rebuildPoints();\n    this.regionSub = this.ctx.regionStore.getRegionUpdateEvent().subscribe(() => this.rebuildPoints());\n    this.ctx.tools.scheduleReadback();\n  }\n\n  setZ(z: number): void {\n    this.image.setZ(z);\n  }\n\n  histogram(channel: number, bins: number): IHistogram | null {\n    return this.image.histogram(channel, bins);\n  }\n\n  setImageSmoothing(enabled: boolean): void {\n    this.image.setImageSmoothing(enabled);\n  }\n\n  setNavigatorVisible(visible: boolean): void {\n    this.image.setNavigatorVisible(visible);\n  }\n\n  dispose(): void {\n    this.regionSub?.unsubscribe();\n    this.regionSub = null;\n    this.image.dispose();\n  }\n\n  /** (Re)build the point layer at the current region centroids. */\n  private rebuildPoints(): void {\n    const v = this.ctx.viewer;\n    if (this.points) {\n      v.layers.remove(this.points);\n      this.points = null;\n    }\n    const centroids = regionCentroids(this.ctx.regionStore.getRegions());\n    if (centroids.length === 0) return;\n    this.points = v.addPoints(centroids, {\n      size: 12,\n      faceColor: [1, 0.85, 0.2, 1],\n      borderColor: [0, 0, 0, 1],\n      borderWidth: 2,\n    });\n  }\n}\n"]}