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

package/esm2022/lib/implementations/napari-js/napari-volume-scene.mjs

@@ -0,0 +1,439 @@
+import { MultiChannelVolumeView, histogramScalar } from 'napari-js';
+import { formatLength } from 'napari-js/overlays';
+import { NapariVolumeZHandle } from './napari-volume-z-handle';
+import { Axes3dGizmo, surface3dControls } from './napari-axes-gizmo';
+import { SCATTER3D_MAX_POINTS, SCATTER3D_MAX_XY, VOLUME_WORLD_INPLANE_REF, isServerlessMultichannel, stackDepth, tintFor, toIHistogram, toNapariGamma, volumeResolutionFor, } from './napari-helpers';
+/** The intensity histogram of an assembled uint8 channel (or the single grayscale volume, key 0). */
+function channelHistogram(data, channel, bins) {
+    if (!data.size)
+        return null;
+    const plane = data.get(channel) ?? data.get(0);
+    return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;
+}
+/** Assemble `info`'s stack into a uint8 volume under the stack progress bar; null once `loading`
+ *  aborts (a Cancel or a new plot). The caller owns the loading flag and takes `loading` once per
+ *  load: a Cancel replaces `ctx.loading()`, and a multichannel volume assembles channels in turn. */
+function assemble(ctx, info, opts, loading, channel) {
+    return ctx.tiles.assembleVolume(info, opts, channel, {
+        signal: loading,
+        progress: (p) => ctx.stack.progress(p),
+    });
+}
+/**
+ * NAPARI_VOLUME / NAPARI_ISOSURFACE (review Appendix B, cluster F): the stack assembled into a
+ * decimated volume — one additive, tinted `VolumeLayer` per channel for a multichannel image, a
+ * single grayscale volume otherwise — with the axes gizmo and the in-view Z-height handle.
+ */
+export class VolumeScene {
+    constructor(ctx, info, rendering) {
+        this.ctx = ctx;
+        this.info = info;
+        this.rendering = rendering;
+        /** napari-js high-level view owning the volume layers. */
+        this.view = null;
+        /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */
+        this.multichannel = false;
+        /** Volume world box at Z-scale 1 (base) + the sampled voxel depth — enough to recompute the
+         *  Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */
+        this.worldBase = null;
+        this.sampledDepth = 1;
+        this.dims = null;
+        /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity
+         *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */
+        this.channelData = new Map();
+        this.gizmo = null;
+        this.zHandle = null;
+        this.displaySub = null;
+    }
+    /**
+     * Assemble and render the volume, then add the axes gizmo + labels and the Z handle and follow
+     * the display state.
+     */
+    async mount() {
+        const { ctx, info } = this;
+        const loading = ctx.loading(); // bail before rendering on a Cancel / new plot
+        const desc = await ctx.tiles.ensureDescriptor(ctx.info());
+        // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so
+        // derive the channel count from imageMeta and assemble each band from its own
+        // channelUrls[z][c] plane (fetchImage does the per-channel routing).
+        const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);
+        const channelCount = simpleMc ? info.imageMeta[0].channelCount : (desc?.channels ?? 1);
+        const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);
+        this.channelData.clear();
+        this.multichannel = multichannel;
+        const view = new MultiChannelVolumeView(ctx.viewer);
+        this.view = view;
+        const { dims, channels } = await this.assembleChannels(desc, channelCount, loading);
+        if (!dims || !channels.length || loading.aborted)
+            return; // cancelled → don't render
+        const world = this.worldBox(dims);
+        // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted
+        // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.
+        this.worldBase = world;
+        this.sampledDepth = Math.max(1, dims.depth);
+        const worldZ = world.depth * ctx.settings.volumeZScale;
+        const voxelSize = [
+            world.width / dims.width,
+            world.height / dims.height,
+            worldZ / this.sampledDepth,
+        ];
+        for (const ch of channels)
+            ch.voxelSize = voxelSize;
+        view.render(this.multichannel ? 'multichannel' : 'grayscale', channels, { rendering: this.rendering });
+        ctx.setImageSize(dims.width, dims.height);
+        this.dims = dims;
+        // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks
+        // the rendered proportions. Physical scale text still comes from the FULL image extent.
+        const box = { width: world.width, height: world.height, depth: worldZ };
+        this.gizmo = new Axes3dGizmo(ctx.viewer, ctx.host, box, this.axesLabels(box), {
+            visible: ctx.settings.axesVisible,
+        });
+        // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue
+        // "Z" axis + label live), so it reads as the Z-height control. Floated a little past the axis
+        // tip (×1.12) so the grip clears the "Z · …" label. Drag ↕ to restretch Z live.
+        this.zHandle = new NapariVolumeZHandle(ctx.host, ctx.viewer.camera3d, {
+            topAnchor: () => [
+                -this.worldBase.width / 2,
+                -this.worldBase.height / 2,
+                ((this.worldBase.depth * ctx.settings.volumeZScale) / 2) * 1.12,
+            ],
+            getScale: () => ctx.settings.volumeZScale,
+            setScale: (s) => this.setZScale(s),
+        });
+        this.followDisplayState();
+    }
+    /**
+     * Assemble each channel's volume from the server tiles (or the single grayscale volume) under
+     * the stack progress bar, with the display settings it is drawn with. `dims` is null when
+     * nothing was assembled (a Cancel, a new plot, or no slices).
+     */
+    async assembleChannels(desc, channelCount, loading) {
+        const { ctx, info } = this;
+        const res = volumeResolutionFor(ctx.settings.resolutionScale);
+        const states = ctx.store.currentChannelStates();
+        // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view
+        // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale
+        // volume). The adapter computes each channel's colormap (incl. the reverse flip) and invert.
+        let dims = null;
+        const channels = [];
+        ctx.stack.loading(true);
+        ctx.stack.progress(0);
+        try {
+            if (this.multichannel) {
+                for (let c = 0; c < channelCount; c++) {
+                    const vol = await assemble(ctx, info, res, loading, c);
+                    if (loading.aborted)
+                        break; // a Cancel / new plot: fetch no further channel
+                    if (!vol)
+                        continue;
+                    dims = vol;
+                    this.channelData.set(c, vol.data);
+                    const st = states.find((s) => s.index === c);
+                    const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: ctx.display.channelTintColormap(color),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+                        invert: ctx.display.invert,
+                        visible: st?.visible ?? true,
+                    });
+                }
+            }
+            else {
+                const vol = await assemble(ctx, info, res, loading);
+                if (vol) {
+                    dims = vol;
+                    this.channelData.set(0, vol.data);
+                    const st = states[0];
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: ctx.display.volumeColormap(st),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+                        invert: ctx.display.invert,
+                    });
+                }
+            }
+        }
+        finally {
+            ctx.stack.loading(false);
+            ctx.stack.progress(0);
+        }
+        return { dims, channels };
+    }
+    /** The volume's world box for the assembled `dims`, independent of the decimate factor. */
+    worldBox(dims) {
+        const { ctx } = this;
+        // Resolution-invariant world box; the per-axis `voxelSize` (napari `scale`) maps the sampled
+        // grid onto it.
+        //
+        // A stack that declares its physical spacing on ALL THREE axes gets its true
+        // extent as the world box — the only way anisotropy survives, and what makes a
+        // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect
+        // brick. It needs none of the reference-box arithmetic: a physical box is
+        // already independent of the decimate factor.
+        //
+        // Everything else keeps that arithmetic. Sizing the box by the sampled voxel
+        // counts made higher in-plane resolution grow X/Y while the depth stayed the
+        // (constant) slice count — so Z appeared to shrink at higher resolution.
+        // Anchoring the in-plane long side to a fixed reference and letting Z span the
+        // full slice count makes the box shape identical at every decimate factor.
+        const meta = ctx.info()?.imageMeta?.[0];
+        const mppXYZ = meta?.mppX && meta?.mppY && meta?.mppZ ? [meta.mppX, meta.mppY, meta.mppZ] : null;
+        // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled
+        // dims are decimated, so sizing a physical box by them would make the world
+        // box depend on the resolution the user happens to be viewing at.
+        const imageDesc = ctx.tiles.currentDescriptor(ctx.info());
+        const fullW = imageDesc?.width ?? meta?.x ?? dims.width;
+        const fullH = imageDesc?.height ?? meta?.y ?? dims.height;
+        const fullD = stackDepth(ctx.info()) || dims.depth;
+        if (mppXYZ) {
+            return {
+                width: fullW * mppXYZ[0],
+                height: fullH * mppXYZ[1],
+                depth: fullD * mppXYZ[2],
+            };
+        }
+        const fullLong = Math.max(1, fullW, fullH);
+        return {
+            width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,
+            height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,
+            depth: fullD,
+        };
+    }
+    /**
+     * The whole stack is already on screen: no plane to step. (This used to write `viewer.dims.z`,
+     * which only a tiled 2D image reads — a volume raymarches every slice — and schedule a readback
+     * of a frame that had not changed. The toolbar shows no slice control in volume / isosurface
+     * mode, as Plotly's isosurface ignores the slice too.)
+     */
+    setZ() {
+        /* nothing to step */
+    }
+    /** The intensity histogram of the assembled (downsampled) uint8 volume for the requested
+     *  channel (multichannel) or the single grayscale volume. */
+    histogram(channel, bins) {
+        return channelHistogram(this.channelData, channel, bins);
+    }
+    isoControls() {
+        if (!this.view)
+            return null;
+        return {
+            setIsoRange: (isoMin, isoMax) => {
+                // Apply to every channel's volume layer.
+                for (const layer of this.view?.layers ?? []) {
+                    layer.contrastLimits = [isoMin, isoMax];
+                    layer.rendering = 'iso';
+                    layer.isoThreshold = 0.5;
+                }
+                this.ctx.viewer.requestRender();
+            },
+        };
+    }
+    surface3dControls() {
+        return this.view ? surface3dControls(this.ctx, () => this.gizmo) : null;
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+        this.gizmo?.destroy();
+        this.gizmo = null;
+        this.zHandle?.destroy();
+        this.zHandle = null;
+        this.worldBase = null;
+    }
+    /**
+     * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only
+     * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is
+     * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts
+     * (resolution changes) so the chosen height sticks.
+     */
+    setZScale(factor) {
+        const { settings } = this.ctx;
+        settings.volumeZScale = Math.min(10, Math.max(0.1, factor));
+        const base = this.worldBase;
+        if (!base || !this.view)
+            return;
+        const worldZ = base.depth * settings.volumeZScale;
+        const vsZ = worldZ / this.sampledDepth;
+        for (const layer of this.view.layers) {
+            const [sx, sy] = layer.voxelSize;
+            layer.voxelSize = [sx, sy, vsZ];
+        }
+        this.gizmo?.setDepth(worldZ, this.axesLabels({ width: base.width, height: base.height, depth: worldZ }));
+        this.zHandle?.reposition();
+        this.ctx.viewer.requestRender();
+    }
+    /** The X/Y/Z axis-end label specs for the gizmo. Anchors are in the volume's centred world box
+     *  (matching the AxesLayer geometry); the scale text reflects the FULL image extent — physical µm
+     *  when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */
+    axesLabels(vol) {
+        const hx = vol.width / 2;
+        const hy = vol.height / 2;
+        const hz = vol.depth / 2;
+        // Measured from the IMAGE's own extent, never from the world box: the box is a
+        // shape (and for a physically sized volume it is already in µm, so reading a
+        // pixel count off it and multiplying by mpp would scale the label twice).
+        const { px, mpp } = this.imageExtent();
+        const len = (n, um) => (um > 0 ? formatLength(n * um, 'µm') : `${n} px`);
+        return [
+            { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },
+            { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },
+            // Physical when the stack declares its slice spacing (`mppZ`) — a resampled
+            // volume knows how thick it is; a plain z-stack can only say how many slices.
+            { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },
+        ];
+    }
+    /**
+     * The image's declared extent in pixels/slices, and its physical spacing per
+     * axis in µm (0 = undeclared, and then that axis reads in pixels).
+     *
+     * One place, because the volume world box and the axis labels have to agree
+     * about what the image's real dimensions are — the sampled grid is decimated and
+     * says nothing about either.
+     */
+    imageExtent() {
+        const info = this.ctx.info();
+        const meta = info?.imageMeta?.[0];
+        const dims = this.dims;
+        const desc = this.ctx.tiles.currentDescriptor(info);
+        const mppX = desc?.mppX || meta?.mppX || 0;
+        return {
+            px: [
+                desc?.width ?? meta?.x ?? dims?.width ?? 1,
+                desc?.height ?? meta?.y ?? dims?.height ?? 1,
+                stackDepth(info) || dims?.depth || 1,
+            ],
+            // A descriptor that reports only mppX is square-pixel by convention, which is
+            // what the 2D scale bar already assumes of it.
+            mpp: [mppX, desc?.mppY || meta?.mppY || mppX, meta?.mppZ || 0],
+        };
+    }
+    /** The store's colormap, reverse, invert and channel windows → the volume's transfer function:
+     *  colour (channel tint or selected colormap), the intensity window (min/max → contrastLimits)
+     *  and gamma, mirroring the grayscale image's display controls so the histogram pane drives the
+     *  3D render. */
+    followDisplayState() {
+        const { display } = this.ctx;
+        this.displaySub = display.watch((channels) => {
+            const view = this.view;
+            if (!view)
+                return;
+            if (this.multichannel) {
+                // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.
+                view.layers.forEach((_, c) => {
+                    const st = channels.find((s) => s.index === c);
+                    view.updateChannel(c, {
+                        colormap: display.channelTintColormap(st?.color ?? '#ffffff'),
+                        invert: display.invert,
+                        ...(st
+                            ? {
+                                contrastLimits: [st.min, st.max],
+                                gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ
+                                visible: st.visible,
+                            }
+                            : {}),
+                    });
+                });
+            }
+            else {
+                const st = channels[0];
+                view.updateChannel(0, {
+                    colormap: display.volumeColormap(st),
+                    invert: display.invert,
+                    ...(st ? { contrastLimits: [st.min, st.max], gamma: toNapariGamma(st.gamma) } : {}),
+                });
+            }
+        });
+    }
+}
+/**
+ * NAPARI_SCATTER3D (review Appendix B, cluster H): the downsampled voxel grid as a 3D point cloud
+ * coloured by intensity (the napari-js analog of Plotly's voxel scatter3d). Assembles a coarse
+ * volume, then emits a flat-strided sample of voxels (capped at `SCATTER3D_MAX_POINTS`).
+ */
+export class Scatter3dScene {
+    constructor(ctx, info) {
+        this.ctx = ctx;
+        this.info = info;
+        this.layer = null;
+        /** The assembled volume (key 0), for the intensity histogram. */
+        this.channelData = new Map();
+        this.displaySub = null;
+    }
+    async mount() {
+        const { ctx } = this;
+        const res = volumeResolutionFor(ctx.settings.resolutionScale);
+        ctx.stack.loading(true);
+        ctx.stack.progress(0);
+        let vol = null;
+        try {
+            vol = await assemble(ctx, this.info, { maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY), sliceStep: res.sliceStep }, ctx.loading());
+        }
+        finally {
+            ctx.stack.loading(false);
+            ctx.stack.progress(0);
+        }
+        if (!vol || ctx.signal.aborted)
+            return;
+        const { data, width, height, depth } = vol;
+        const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect
+        const total = width * height * depth;
+        const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));
+        const pos = [];
+        const val = [];
+        for (let i = 0; i < total; i += stride) {
+            const x = i % width;
+            const y = Math.floor(i / width) % height;
+            const zi = Math.floor(i / (width * height));
+            pos.push(x, y, zi * zScale);
+            val.push(data[i]);
+        }
+        const st = ctx.store.currentChannelStates()[0];
+        this.layer = ctx.viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {
+            colormap: ctx.display.volumeColormap(st),
+            contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+            invert: ctx.display.invert,
+            size: 3,
+        });
+        ctx.setImageSize(width, height);
+        // Feed the intensity histogram from the assembled volume (key 0).
+        this.channelData.clear();
+        this.channelData.set(0, data);
+        // Store colormap / reverse / invert / channel window → the cloud's colormap + contrast.
+        this.displaySub = ctx.display.watch((channels) => {
+            const layer = this.layer;
+            if (!layer)
+                return;
+            const s = channels[0];
+            layer.colormap = ctx.display.volumeColormap(s);
+            layer.invert = ctx.display.invert;
+            if (s)
+                layer.contrastLimits = [s.min, s.max];
+            ctx.viewer.requestRender();
+        });
+        ctx.tools.scheduleReadback();
+    }
+    /** The whole stack is already on screen: no plane to step. */
+    setZ() {
+        /* nothing to step */
+    }
+    histogram(channel, bins) {
+        return channelHistogram(this.channelData, channel, bins);
+    }
+    surface3dControls() {
+        return this.layer ? surface3dControls(this.ctx, () => null) : null;
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-scene.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAMlD,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,EAAE,WAAW,EAAQ,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,wBAAwB,EACxB,wBAAwB,EACxB,UAAU,EACV,OAAO,EACP,YAAY,EACZ,aAAa,EACb,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAG1B,qGAAqG;AACrG,SAAS,gBAAgB,CAAC,IAA6B,EAAE,OAAe,EAAE,IAAY;IACpF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC/C,OAAO,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC3E,CAAC;AAED;;qGAEqG;AACrG,SAAS,QAAQ,CACf,GAAiB,EACjB,IAA4B,EAC5B,IAA+C,EAC/C,OAAoB,EACpB,OAAgB;IAEhB,OAAO,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE;QACnD,MAAM,EAAE,OAAO;QACf,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;KACvC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,OAAO,WAAW;IAiBtB,YACmB,GAAiB,EACjB,IAA4B,EAC5B,SAAwB;QAFxB,QAAG,GAAH,GAAG,CAAc;QACjB,SAAI,GAAJ,IAAI,CAAwB;QAC5B,cAAS,GAAT,SAAS,CAAe;QAnB3C,0DAA0D;QAC1D,SAAI,GAAkC,IAAI,CAAC;QAC3C,iGAAiG;QACzF,iBAAY,GAAG,KAAK,CAAC;QAC7B;6FACqF;QAC7E,cAAS,GAAgB,IAAI,CAAC;QAC9B,iBAAY,GAAG,CAAC,CAAC;QACjB,SAAI,GAAgB,IAAI,CAAC;QACjC;gGACwF;QACvE,gBAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;QAC7D,UAAK,GAAuB,IAAI,CAAC;QACzB,YAAO,GAA+B,IAAI,CAAC;QAC3C,eAAU,GAAwB,IAAI,CAAC;IAM5C,CAAC;IAEJ;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;QAC3B,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,+CAA+C;QAC9E,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1D,8EAA8E;QAC9E,8EAA8E;QAC9E,qEAAqE;QACrE,MAAM,QAAQ,GAAG,wBAAwB,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QAC1E,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAK,CAAC,SAAU,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,IAAI,CAAC,CAAC,CAAC;QACzF,MAAM,YAAY,GAAG,QAAQ,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,YAAY,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC;QAE5E,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,MAAM,IAAI,GAAG,IAAI,sBAAsB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;QACpF,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,OAAO,CAAC,OAAO;YAAE,OAAO,CAAC,2BAA2B;QAErF,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,iGAAiG;QACjG,4FAA4F;QAC5F,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC;QACvD,MAAM,SAAS,GAA6B;YAC1C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK;YACxB,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM;YAC1B,MAAM,GAAG,IAAI,CAAC,YAAY;SAC3B,CAAC;QACF,KAAK,MAAM,EAAE,IAAI,QAAQ;YAAE,EAAE,CAAC,SAAS,GAAG,SAAS,CAAC;QAEpD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QACvG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QAEjB,gGAAgG;QAChG,wFAAwF;QACxF,MAAM,GAAG,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QACxE,IAAI,CAAC,KAAK,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;YAC5E,OAAO,EAAE,GAAG,CAAC,QAAQ,CAAC,WAAW;SAClC,CAAC,CAAC;QACH,4FAA4F;QAC5F,8FAA8F;QAC9F,gFAAgF;QAChF,IAAI,CAAC,OAAO,GAAG,IAAI,mBAAmB,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE;YACpE,SAAS,EAAE,GAAG,EAAE,CAAC;gBACf,CAAC,IAAI,CAAC,SAAU,CAAC,KAAK,GAAG,CAAC;gBAC1B,CAAC,IAAI,CAAC,SAAU,CAAC,MAAM,GAAG,CAAC;gBAC3B,CAAC,CAAC,IAAI,CAAC,SAAU,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI;aACjE;YACD,QAAQ,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY;YACzC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;SACnC,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,gBAAgB,CAC5B,IAA2B,EAC3B,YAAoB,EACpB,OAAoB;QAEpB,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;QAC3B,MAAM,GAAG,GAAG,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAC9D,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,oBAAoB,EAAE,CAAC;QAEhD,+FAA+F;QAC/F,8FAA8F;QAC9F,6FAA6F;QAC7F,IAAI,IAAI,GAAgB,IAAI,CAAC;QAC7B,MAAM,QAAQ,GAAoB,EAAE,CAAC;QACrC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;oBACtC,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;oBACvD,IAAI,OAAO,CAAC,OAAO;wBAAE,MAAM,CAAC,gDAAgD;oBAC5E,IAAI,CAAC,GAAG;wBAAE,SAAS;oBACnB,IAAI,GAAG,GAAG,CAAC;oBACX,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;oBAClC,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;oBAC7C,MAAM,KAAK,GAAG,EAAE,EAAE,KAAK,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;oBACvE,QAAQ,CAAC,IAAI,CAAC;wBACZ,IAAI,EAAE,GAAG,CAAC,IAAI;wBACd,KAAK,EAAE,GAAG,CAAC,KAAK;wBAChB,MAAM,EAAE,GAAG,CAAC,MAAM;wBAClB,KAAK,EAAE,GAAG,CAAC,KAAK;wBAChB,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC;wBAChD,cAAc,EAAE,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG,CAAC;wBAC9C,KAAK,EAAE,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,yBAAyB;wBAC1D,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM;wBAC1B,OAAO,EAAE,EAAE,EAAE,OAAO,IAAI,IAAI;qBAC7B,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC;gBACpD,IAAI,GAAG,EAAE,CAAC;oBACR,IAAI,GAAG,GAAG,CAAC;oBACX,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;oBAClC,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;oBACrB,QAAQ,CAAC,IAAI,CAAC;wBACZ,IAAI,EAAE,GAAG,CAAC,IAAI;wBACd,KAAK,EAAE,GAAG,CAAC,KAAK;wBAChB,MAAM,EAAE,GAAG,CAAC,MAAM;wBAClB,KAAK,EAAE,GAAG,CAAC,KAAK;wBAChB,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;wBACxC,cAAc,EAAE,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG,CAAC;wBAC9C,KAAK,EAAE,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,yBAAyB;wBAC1D,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM;qBAC3B,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACzB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC5B,CAAC;IAED,2FAA2F;IACnF,QAAQ,CAAC,IAAU;QACzB,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QACrB,6FAA6F;QAC7F,gBAAgB;QAChB,EAAE;QACF,6EAA6E;QAC7E,+EAA+E;QAC/E,6EAA6E;QAC7E,0EAA0E;QAC1E,8CAA8C;QAC9C,EAAE;QACF,6EAA6E;QAC7E,6EAA6E;QAC7E,yEAAyE;QACzE,+EAA+E;QAC/E,2EAA2E;QAC3E,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,MAAM,GACV,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACpF,+EAA+E;QAC/E,4EAA4E;QAC5E,kEAAkE;QAClE,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,SAAS,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC;QACxD,MAAM,KAAK,GAAG,SAAS,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;QAC1D,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC;QACnD,IAAI,MAAM,EAAE,CAAC;YACX,OAAO;gBACL,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;gBACxB,MAAM,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;gBACzB,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;aACzB,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAC3C,OAAO;YACL,KAAK,EAAE,CAAC,KAAK,GAAG,wBAAwB,CAAC,GAAG,QAAQ;YACpD,MAAM,EAAE,CAAC,KAAK,GAAG,wBAAwB,CAAC,GAAG,QAAQ;YACrD,KAAK,EAAE,KAAK;SACb,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,IAAI;QACF,qBAAqB;IACvB,CAAC;IAED;iEAC6D;IAC7D,SAAS,CAAC,OAAe,EAAE,IAAY;QACrC,OAAO,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QAC5B,OAAO;YACL,WAAW,EAAE,CAAC,MAAc,EAAE,MAAc,EAAQ,EAAE;gBACpD,yCAAyC;gBACzC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC;oBAC5C,KAAK,CAAC,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;oBACxC,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC;oBACxB,KAAK,CAAC,YAAY,GAAG,GAAG,CAAC;gBAC3B,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;YAClC,CAAC;SACF,CAAC;IACJ,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1E,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACxB,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,MAAc;QACtB,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC;QAC9B,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;QAC5B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,GAAG,QAAQ,CAAC,YAAY,CAAC;QAClD,MAAM,GAAG,GAAG,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC;QACvC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACrC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;YACjC,KAAK,CAAC,SAAS,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;QACzG,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAClC,CAAC;IAED;;uEAEmE;IACnE,UAAU,CAAC,GAAS;QAClB,MAAM,EAAE,GAAG,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;QACzB,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1B,MAAM,EAAE,GAAG,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;QACzB,+EAA+E;QAC/E,6EAA6E;QAC7E,0EAA0E;QAC1E,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,CAAC,CAAS,EAAE,EAAU,EAAU,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjG,OAAO;YACL,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;YAC/E,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;YAC/E,4EAA4E;YAC5E,8EAA8E;YAC9E,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;SAChF,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACK,WAAW;QACjB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC;QAC3C,OAAO;YACL,EAAE,EAAE;gBACF,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC,IAAI,IAAI,EAAE,KAAK,IAAI,CAAC;gBAC1C,IAAI,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC,IAAI,IAAI,EAAE,MAAM,IAAI,CAAC;gBAC5C,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,KAAK,IAAI,CAAC;aACrC;YACD,8EAA8E;YAC9E,+CAA+C;YAC/C,GAAG,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC,CAAC;SAC/D,CAAC;IACJ,CAAC;IAED;;;qBAGiB;IACT,kBAAkB;QACxB,MAAM,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YACvB,IAAI,CAAC,IAAI;gBAAE,OAAO;YAClB,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,yFAAyF;gBACzF,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;oBAC3B,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;oBAC/C,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE;wBACpB,QAAQ,EAAE,OAAO,CAAC,mBAAmB,CAAC,EAAE,EAAE,KAAK,IAAI,SAAS,CAAC;wBAC7D,MAAM,EAAE,OAAO,CAAC,MAAM;wBACtB,GAAG,CAAC,EAAE;4BACJ,CAAC,CAAC;gCACE,cAAc,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAqB;gCACpD,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,yBAAyB;gCACzD,OAAO,EAAE,EAAE,CAAC,OAAO;6BACpB;4BACH,CAAC,CAAC,EAAE,CAAC;qBACR,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE;oBACpB,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;oBACpC,MAAM,EAAE,OAAO,CAAC,MAAM;oBACtB,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAqB,EAAE,KAAK,EAAE,aAAa,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBACxG,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,cAAc;IAMzB,YACmB,GAAiB,EACjB,IAA4B;QAD5B,QAAG,GAAH,GAAG,CAAc;QACjB,SAAI,GAAJ,IAAI,CAAwB;QAPvC,UAAK,GAAyB,IAAI,CAAC;QAC3C,iEAAiE;QAChD,gBAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;QACrD,eAAU,GAAwB,IAAI,CAAC;IAK5C,CAAC;IAEJ,KAAK,CAAC,KAAK;QACT,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QACrB,MAAM,GAAG,GAAG,mBAAmB,CAAC,GAAG,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAC9D,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,GAAG,GAA2B,IAAI,CAAC;QACvC,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,QAAQ,CAClB,GAAG,EACH,IAAI,CAAC,IAAI,EACT,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,EAChF,GAAG,CAAC,OAAO,EAAE,CACd,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACzB,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO;YAAE,OAAO;QAEvC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC;QAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,iBAAiB;QAC9E,MAAM,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAC;QACrC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,oBAAoB,CAAC,CAAC,CAAC;QACpE,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,MAAM,EAAE,CAAC;YACvC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACpB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC;YACzC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC;YAC5C,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,CAAC;YAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/C,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE;YAChF,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;YACxC,cAAc,EAAE,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,GAAG,CAAC;YAC9C,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,MAAM;YAC1B,IAAI,EAAE,CAAC;SACR,CAAC,CAAC;QACH,GAAG,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAChC,kEAAkE;QAClE,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;QAC9B,wFAAwF;QACxF,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YACzB,IAAI,CAAC,KAAK;gBAAE,OAAO;YACnB,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YACtB,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YAC/C,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;YAClC,IAAI,CAAC;gBAAE,KAAK,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;YAC7C,GAAG,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,GAAG,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAC/B,CAAC;IAED,8DAA8D;IAC9D,IAAI;QACF,qBAAqB;IACvB,CAAC;IAED,SAAS,CAAC,OAAe,EAAE,IAAY;QACrC,OAAO,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrE,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;CACF","sourcesContent":["import { Subscription } from 'rxjs';\nimport { MultiChannelVolumeView, histogramScalar } from 'napari-js';\nimport type { Points3DLayer, VolumeChannel } from 'napari-js';\nimport { formatLength } from 'napari-js/overlays';\nimport type { AxisLabelSpec } from 'napari-js/overlays';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { IIsosurfaceControls, ISurface3dControls } from '../../contracts/visualizer.contract';\nimport { NapariVolumeZHandle } from './napari-volume-z-handle';\nimport { AssembledVolume } from './napari-tile-client';\nimport { TileDescriptor } from '../tile-server';\nimport { Axes3dGizmo, Box3, surface3dControls } from './napari-axes-gizmo';\nimport {\n  SCATTER3D_MAX_POINTS,\n  SCATTER3D_MAX_XY,\n  VOLUME_WORLD_INPLANE_REF,\n  isServerlessMultichannel,\n  stackDepth,\n  tintFor,\n  toIHistogram,\n  toNapariGamma,\n  volumeResolutionFor,\n} from './napari-helpers';\nimport type { NapariScene, SceneContext } from './napari-scene';\n\n/** The intensity histogram of an assembled uint8 channel (or the single grayscale volume, key 0). */\nfunction channelHistogram(data: Map<number, Uint8Array>, channel: number, bins: number): IHistogram | null {\n  if (!data.size) return null;\n  const plane = data.get(channel) ?? data.get(0);\n  return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;\n}\n\n/** Assemble `info`'s stack into a uint8 volume under the stack progress bar; null once `loading`\n *  aborts (a Cancel or a new plot). The caller owns the loading flag and takes `loading` once per\n *  load: a Cancel replaces `ctx.loading()`, and a multichannel volume assembles channels in turn. */\nfunction assemble(\n  ctx: SceneContext,\n  info: IImageInfo | undefined,\n  opts: { maxSlice?: number; sliceStep?: number },\n  loading: AbortSignal,\n  channel?: number,\n): Promise<AssembledVolume | null> {\n  return ctx.tiles.assembleVolume(info, opts, channel, {\n    signal: loading,\n    progress: (p) => ctx.stack.progress(p),\n  });\n}\n\n/**\n * NAPARI_VOLUME / NAPARI_ISOSURFACE (review Appendix B, cluster F): the stack assembled into a\n * decimated volume — one additive, tinted `VolumeLayer` per channel for a multichannel image, a\n * single grayscale volume otherwise — with the axes gizmo and the in-view Z-height handle.\n */\nexport class VolumeScene implements NapariScene {\n  /** napari-js high-level view owning the volume layers. */\n  view: MultiChannelVolumeView | null = null;\n  /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */\n  private multichannel = false;\n  /** Volume world box at Z-scale 1 (base) + the sampled voxel depth — enough to recompute the\n   *  Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */\n  private worldBase: Box3 | null = null;\n  private sampledDepth = 1;\n  private dims: Box3 | null = null;\n  /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity\n   *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */\n  private readonly channelData = new Map<number, Uint8Array>();\n  gizmo: Axes3dGizmo | null = null;\n  private zHandle: NapariVolumeZHandle | null = null;\n  private displaySub: Subscription | null = null;\n\n  constructor(\n    private readonly ctx: SceneContext,\n    private readonly info: IImageInfo | undefined,\n    private readonly rendering: 'iso' | 'mip',\n  ) {}\n\n  /**\n   * Assemble and render the volume, then add the axes gizmo + labels and the Z handle and follow\n   * the display state.\n   */\n  async mount(): Promise<void> {\n    const { ctx, info } = this;\n    const loading = ctx.loading(); // bail before rendering on a Cancel / new plot\n    const desc = await ctx.tiles.ensureDescriptor(ctx.info());\n    // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so\n    // derive the channel count from imageMeta and assemble each band from its own\n    // channelUrls[z][c] plane (fetchImage does the per-channel routing).\n    const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);\n    const channelCount = simpleMc ? info!.imageMeta![0].channelCount : (desc?.channels ?? 1);\n    const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);\n\n    this.channelData.clear();\n    this.multichannel = multichannel;\n    const view = new MultiChannelVolumeView(ctx.viewer);\n    this.view = view;\n    const { dims, channels } = await this.assembleChannels(desc, channelCount, loading);\n    if (!dims || !channels.length || loading.aborted) return; // cancelled → don't render\n\n    const world = this.worldBox(dims);\n    // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted\n    // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.\n    this.worldBase = world;\n    this.sampledDepth = Math.max(1, dims.depth);\n    const worldZ = world.depth * ctx.settings.volumeZScale;\n    const voxelSize: [number, number, number] = [\n      world.width / dims.width,\n      world.height / dims.height,\n      worldZ / this.sampledDepth,\n    ];\n    for (const ch of channels) ch.voxelSize = voxelSize;\n\n    view.render(this.multichannel ? 'multichannel' : 'grayscale', channels, { rendering: this.rendering });\n    ctx.setImageSize(dims.width, dims.height);\n    this.dims = dims;\n\n    // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks\n    // the rendered proportions. Physical scale text still comes from the FULL image extent.\n    const box = { width: world.width, height: world.height, depth: worldZ };\n    this.gizmo = new Axes3dGizmo(ctx.viewer, ctx.host, box, this.axesLabels(box), {\n      visible: ctx.settings.axesVisible,\n    });\n    // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue\n    // \"Z\" axis + label live), so it reads as the Z-height control. Floated a little past the axis\n    // tip (×1.12) so the grip clears the \"Z · …\" label. Drag ↕ to restretch Z live.\n    this.zHandle = new NapariVolumeZHandle(ctx.host, ctx.viewer.camera3d, {\n      topAnchor: () => [\n        -this.worldBase!.width / 2,\n        -this.worldBase!.height / 2,\n        ((this.worldBase!.depth * ctx.settings.volumeZScale) / 2) * 1.12,\n      ],\n      getScale: () => ctx.settings.volumeZScale,\n      setScale: (s) => this.setZScale(s),\n    });\n    this.followDisplayState();\n  }\n\n  /**\n   * Assemble each channel's volume from the server tiles (or the single grayscale volume) under\n   * the stack progress bar, with the display settings it is drawn with. `dims` is null when\n   * nothing was assembled (a Cancel, a new plot, or no slices).\n   */\n  private async assembleChannels(\n    desc: TileDescriptor | null,\n    channelCount: number,\n    loading: AbortSignal,\n  ): Promise<{ dims: Box3 | null; channels: VolumeChannel[] }> {\n    const { ctx, info } = this;\n    const res = volumeResolutionFor(ctx.settings.resolutionScale);\n    const states = ctx.store.currentChannelStates();\n\n    // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view\n    // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale\n    // volume). The adapter computes each channel's colormap (incl. the reverse flip) and invert.\n    let dims: Box3 | null = null;\n    const channels: VolumeChannel[] = [];\n    ctx.stack.loading(true);\n    ctx.stack.progress(0);\n    try {\n      if (this.multichannel) {\n        for (let c = 0; c < channelCount; c++) {\n          const vol = await assemble(ctx, info, res, loading, c);\n          if (loading.aborted) break; // a Cancel / new plot: fetch no further channel\n          if (!vol) continue;\n          dims = vol;\n          this.channelData.set(c, vol.data);\n          const st = states.find((s) => s.index === c);\n          const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: ctx.display.channelTintColormap(color),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n            invert: ctx.display.invert,\n            visible: st?.visible ?? true,\n          });\n        }\n      } else {\n        const vol = await assemble(ctx, info, res, loading);\n        if (vol) {\n          dims = vol;\n          this.channelData.set(0, vol.data);\n          const st = states[0];\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: ctx.display.volumeColormap(st),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n            invert: ctx.display.invert,\n          });\n        }\n      }\n    } finally {\n      ctx.stack.loading(false);\n      ctx.stack.progress(0);\n    }\n    return { dims, channels };\n  }\n\n  /** The volume's world box for the assembled `dims`, independent of the decimate factor. */\n  private worldBox(dims: Box3): Box3 {\n    const { ctx } = this;\n    // Resolution-invariant world box; the per-axis `voxelSize` (napari `scale`) maps the sampled\n    // grid onto it.\n    //\n    // A stack that declares its physical spacing on ALL THREE axes gets its true\n    // extent as the world box — the only way anisotropy survives, and what makes a\n    // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect\n    // brick. It needs none of the reference-box arithmetic: a physical box is\n    // already independent of the decimate factor.\n    //\n    // Everything else keeps that arithmetic. Sizing the box by the sampled voxel\n    // counts made higher in-plane resolution grow X/Y while the depth stayed the\n    // (constant) slice count — so Z appeared to shrink at higher resolution.\n    // Anchoring the in-plane long side to a fixed reference and letting Z span the\n    // full slice count makes the box shape identical at every decimate factor.\n    const meta = ctx.info()?.imageMeta?.[0];\n    const mppXYZ: [number, number, number] | null =\n      meta?.mppX && meta?.mppY && meta?.mppZ ? [meta.mppX, meta.mppY, meta.mppZ] : null;\n    // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled\n    // dims are decimated, so sizing a physical box by them would make the world\n    // box depend on the resolution the user happens to be viewing at.\n    const imageDesc = ctx.tiles.currentDescriptor(ctx.info());\n    const fullW = imageDesc?.width ?? meta?.x ?? dims.width;\n    const fullH = imageDesc?.height ?? meta?.y ?? dims.height;\n    const fullD = stackDepth(ctx.info()) || dims.depth;\n    if (mppXYZ) {\n      return {\n        width: fullW * mppXYZ[0],\n        height: fullH * mppXYZ[1],\n        depth: fullD * mppXYZ[2],\n      };\n    }\n    const fullLong = Math.max(1, fullW, fullH);\n    return {\n      width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      depth: fullD,\n    };\n  }\n\n  /**\n   * The whole stack is already on screen: no plane to step. (This used to write `viewer.dims.z`,\n   * which only a tiled 2D image reads — a volume raymarches every slice — and schedule a readback\n   * of a frame that had not changed. The toolbar shows no slice control in volume / isosurface\n   * mode, as Plotly's isosurface ignores the slice too.)\n   */\n  setZ(): void {\n    /* nothing to step */\n  }\n\n  /** The intensity histogram of the assembled (downsampled) uint8 volume for the requested\n   *  channel (multichannel) or the single grayscale volume. */\n  histogram(channel: number, bins: number): IHistogram | null {\n    return channelHistogram(this.channelData, channel, bins);\n  }\n\n  isoControls(): IIsosurfaceControls | null {\n    if (!this.view) return null;\n    return {\n      setIsoRange: (isoMin: number, isoMax: number): void => {\n        // Apply to every channel's volume layer.\n        for (const layer of this.view?.layers ?? []) {\n          layer.contrastLimits = [isoMin, isoMax];\n          layer.rendering = 'iso';\n          layer.isoThreshold = 0.5;\n        }\n        this.ctx.viewer.requestRender();\n      },\n    };\n  }\n\n  surface3dControls(): ISurface3dControls | null {\n    return this.view ? surface3dControls(this.ctx, () => this.gizmo) : null;\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.gizmo?.destroy();\n    this.gizmo = null;\n    this.zHandle?.destroy();\n    this.zHandle = null;\n    this.worldBase = null;\n  }\n\n  /**\n   * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only\n   * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is\n   * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts\n   * (resolution changes) so the chosen height sticks.\n   */\n  setZScale(factor: number): void {\n    const { settings } = this.ctx;\n    settings.volumeZScale = Math.min(10, Math.max(0.1, factor));\n    const base = this.worldBase;\n    if (!base || !this.view) return;\n    const worldZ = base.depth * settings.volumeZScale;\n    const vsZ = worldZ / this.sampledDepth;\n    for (const layer of this.view.layers) {\n      const [sx, sy] = layer.voxelSize;\n      layer.voxelSize = [sx, sy, vsZ];\n    }\n    this.gizmo?.setDepth(worldZ, this.axesLabels({ width: base.width, height: base.height, depth: worldZ }));\n    this.zHandle?.reposition();\n    this.ctx.viewer.requestRender();\n  }\n\n  /** The X/Y/Z axis-end label specs for the gizmo. Anchors are in the volume's centred world box\n   *  (matching the AxesLayer geometry); the scale text reflects the FULL image extent — physical µm\n   *  when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */\n  axesLabels(vol: Box3): AxisLabelSpec[] {\n    const hx = vol.width / 2;\n    const hy = vol.height / 2;\n    const hz = vol.depth / 2;\n    // Measured from the IMAGE's own extent, never from the world box: the box is a\n    // shape (and for a physically sized volume it is already in µm, so reading a\n    // pixel count off it and multiplying by mpp would scale the label twice).\n    const { px, mpp } = this.imageExtent();\n    const len = (n: number, um: number): string => (um > 0 ? formatLength(n * um, 'µm') : `${n} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },\n      // Physical when the stack declares its slice spacing (`mppZ`) — a resampled\n      // volume knows how thick it is; a plain z-stack can only say how many slices.\n      { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },\n    ];\n  }\n\n  /**\n   * The image's declared extent in pixels/slices, and its physical spacing per\n   * axis in µm (0 = undeclared, and then that axis reads in pixels).\n   *\n   * One place, because the volume world box and the axis labels have to agree\n   * about what the image's real dimensions are — the sampled grid is decimated and\n   * says nothing about either.\n   */\n  private imageExtent(): { px: [number, number, number]; mpp: [number, number, number] } {\n    const info = this.ctx.info();\n    const meta = info?.imageMeta?.[0];\n    const dims = this.dims;\n    const desc = this.ctx.tiles.currentDescriptor(info);\n    const mppX = desc?.mppX || meta?.mppX || 0;\n    return {\n      px: [\n        desc?.width ?? meta?.x ?? dims?.width ?? 1,\n        desc?.height ?? meta?.y ?? dims?.height ?? 1,\n        stackDepth(info) || dims?.depth || 1,\n      ],\n      // A descriptor that reports only mppX is square-pixel by convention, which is\n      // what the 2D scale bar already assumes of it.\n      mpp: [mppX, desc?.mppY || meta?.mppY || mppX, meta?.mppZ || 0],\n    };\n  }\n\n  /** The store's colormap, reverse, invert and channel windows → the volume's transfer function:\n   *  colour (channel tint or selected colormap), the intensity window (min/max → contrastLimits)\n   *  and gamma, mirroring the grayscale image's display controls so the histogram pane drives the\n   *  3D render. */\n  private followDisplayState(): void {\n    const { display } = this.ctx;\n    this.displaySub = display.watch((channels) => {\n      const view = this.view;\n      if (!view) return;\n      if (this.multichannel) {\n        // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.\n        view.layers.forEach((_, c) => {\n          const st = channels.find((s) => s.index === c);\n          view.updateChannel(c, {\n            colormap: display.channelTintColormap(st?.color ?? '#ffffff'),\n            invert: display.invert,\n            ...(st\n              ? {\n                  contrastLimits: [st.min, st.max] as [number, number],\n                  gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ\n                  visible: st.visible,\n                }\n              : {}),\n          });\n        });\n      } else {\n        const st = channels[0];\n        view.updateChannel(0, {\n          colormap: display.volumeColormap(st),\n          invert: display.invert,\n          ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: toNapariGamma(st.gamma) } : {}),\n        });\n      }\n    });\n  }\n}\n\n/**\n * NAPARI_SCATTER3D (review Appendix B, cluster H): the downsampled voxel grid as a 3D point cloud\n * coloured by intensity (the napari-js analog of Plotly's voxel scatter3d). Assembles a coarse\n * volume, then emits a flat-strided sample of voxels (capped at `SCATTER3D_MAX_POINTS`).\n */\nexport class Scatter3dScene implements NapariScene {\n  private layer: Points3DLayer | null = null;\n  /** The assembled volume (key 0), for the intensity histogram. */\n  private readonly channelData = new Map<number, Uint8Array>();\n  private displaySub: Subscription | null = null;\n\n  constructor(\n    private readonly ctx: SceneContext,\n    private readonly info: IImageInfo | undefined,\n  ) {}\n\n  async mount(): Promise<void> {\n    const { ctx } = this;\n    const res = volumeResolutionFor(ctx.settings.resolutionScale);\n    ctx.stack.loading(true);\n    ctx.stack.progress(0);\n    let vol: AssembledVolume | null = null;\n    try {\n      vol = await assemble(\n        ctx,\n        this.info,\n        { maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY), sliceStep: res.sliceStep },\n        ctx.loading(),\n      );\n    } finally {\n      ctx.stack.loading(false);\n      ctx.stack.progress(0);\n    }\n    if (!vol || ctx.signal.aborted) return;\n\n    const { data, width, height, depth } = vol;\n    const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect\n    const total = width * height * depth;\n    const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));\n    const pos: number[] = [];\n    const val: number[] = [];\n    for (let i = 0; i < total; i += stride) {\n      const x = i % width;\n      const y = Math.floor(i / width) % height;\n      const zi = Math.floor(i / (width * height));\n      pos.push(x, y, zi * zScale);\n      val.push(data[i]);\n    }\n\n    const st = ctx.store.currentChannelStates()[0];\n    this.layer = ctx.viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {\n      colormap: ctx.display.volumeColormap(st),\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      invert: ctx.display.invert,\n      size: 3,\n    });\n    ctx.setImageSize(width, height);\n    // Feed the intensity histogram from the assembled volume (key 0).\n    this.channelData.clear();\n    this.channelData.set(0, data);\n    // Store colormap / reverse / invert / channel window → the cloud's colormap + contrast.\n    this.displaySub = ctx.display.watch((channels) => {\n      const layer = this.layer;\n      if (!layer) return;\n      const s = channels[0];\n      layer.colormap = ctx.display.volumeColormap(s);\n      layer.invert = ctx.display.invert;\n      if (s) layer.contrastLimits = [s.min, s.max];\n      ctx.viewer.requestRender();\n    });\n    ctx.tools.scheduleReadback();\n  }\n\n  /** The whole stack is already on screen: no plane to step. */\n  setZ(): void {\n    /* nothing to step */\n  }\n\n  histogram(channel: number, bins: number): IHistogram | null {\n    return channelHistogram(this.channelData, channel, bins);\n  }\n\n  surface3dControls(): ISurface3dControls | null {\n    return this.layer ? surface3dControls(this.ctx, () => null) : null;\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-volume-z-handle.mjs

@@ -1,14 +1,14 @@
 /**
  * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn
- * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label
- * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes
+ * over the 3D canvas at the projected top-face centre of the volume box (projected with napari-js's
+ * {@link projectPoint}, as the axes labels are, so it tracks the box as the volume orbits). Dragging it up makes
  * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and
  * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).
  *
- * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays
- * updated on every `camera3d.changed`, but this one accepts pointer input.
+ * Direct-manipulation counterpart of napari-js's `AxesLabelsOverlay`: both are absolute-positioned
+ * overlays updated on every `camera3d.changed`, but this one accepts pointer input.
  */
-import { projectPoint } from './napari-axes-labels';
+import { projectPoint } from 'napari-js';
 const DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };
 export class NapariVolumeZHandle {
     constructor(host, camera3d, opts) {
@@ -123,4 +123,4 @@ export class NapariVolumeZHandle {
         this.el.parentNode?.removeChild(this.el);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-z-handle.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-z-handle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn\n * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label\n * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes\n * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and\n * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).\n *\n * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays\n * updated on every `camera3d.changed`, but this one accepts pointer input.\n */\nimport { AxesLabelCamera3D, projectPoint } from './napari-axes-labels';\n\nexport interface VolumeZHandleOptions {\n  /** Current top-face-centre world point (the box is centred at the origin, so `[0, 0, +halfZ]`). */\n  topAnchor: () => [number, number, number];\n  /** The current Z-scale factor (1 = the volume's default proportions). */\n  getScale: () => number;\n  /** Apply a new Z-scale factor — the host restretches the volume + axes and repositions overlays. */\n  setScale: (scale: number) => void;\n  /** Vertical drag (px) for one doubling/halving of the Z height. Larger = less sensitive. */\n  pixelsPerDouble?: number;\n  /** Clamp for the Z-scale factor. */\n  minScale?: number;\n  maxScale?: number;\n}\n\nconst DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };\n\nexport class NapariVolumeZHandle {\n  private readonly el: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private readonly opts: Required<VolumeZHandleOptions>;\n  private visible = true;\n  private dragging = false;\n  private startY = 0;\n  private startScale = 1;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: AxesLabelCamera3D,\n    opts: VolumeZHandleOptions,\n  ) {\n    this.opts = { ...DEFAULTS, ...opts };\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      zIndex: '31',\n      width: '22px',\n      height: '22px',\n      marginLeft: '-11px',\n      marginTop: '-11px',\n      borderRadius: '50%',\n      background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)\n      border: '1.5px solid #fff',\n      boxShadow: '0 0 4px rgba(0,0,0,0.6)',\n      color: '#fff',\n      font: '13px sans-serif',\n      lineHeight: '20px',\n      textAlign: 'center',\n      cursor: 'ns-resize',\n      touchAction: 'none',\n      userSelect: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.el.textContent = '↕';\n    this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';\n    this.host.appendChild(this.el);\n\n    this.el.addEventListener('pointerdown', this.onPointerDown);\n    this.el.addEventListener('pointermove', this.onPointerMove);\n    this.el.addEventListener('pointerup', this.onPointerUp);\n    this.el.addEventListener('pointercancel', this.onPointerUp);\n    this.el.addEventListener('dblclick', this.onDoubleClick);\n\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.reposition());\n      this.resizeObserver.observe(this.host);\n    }\n    this.reposition();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.reposition();\n  }\n\n  /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after\n   *  the host applies a new scale (so the grip follows the growing/shrinking box). */\n  reposition(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      this.el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);\n    if (!s.visible) {\n      this.el.style.display = 'none';\n      return;\n    }\n    this.el.style.display = '';\n    this.el.style.left = `${s.x}px`;\n    this.el.style.top = `${s.y}px`;\n  }\n\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.dragging = true;\n    this.startY = e.clientY;\n    this.startScale = this.opts.getScale();\n    this.el.setPointerCapture?.(e.pointerId);\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    e.preventDefault();\n    e.stopPropagation();\n    // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.\n    const dy = e.clientY - this.startY;\n    const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);\n    const next = Math.min(\n      this.opts.maxScale,\n      Math.max(this.opts.minScale, this.startScale * factor),\n    );\n    this.opts.setScale(next);\n    this.reposition();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    this.dragging = false;\n    if (this.el.hasPointerCapture?.(e.pointerId)) this.el.releasePointerCapture?.(e.pointerId);\n  };\n\n  private readonly onDoubleClick = (e: MouseEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.opts.setScale(1);\n    this.reposition();\n  };\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.el.removeEventListener('pointerdown', this.onPointerDown);\n    this.el.removeEventListener('pointermove', this.onPointerMove);\n    this.el.removeEventListener('pointerup', this.onPointerUp);\n    this.el.removeEventListener('pointercancel', this.onPointerUp);\n    this.el.removeEventListener('dblclick', this.onDoubleClick);\n    this.el.parentNode?.removeChild(this.el);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-z-handle.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-z-handle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAsBzC,MAAM,QAAQ,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;AAEvE,MAAM,OAAO,mBAAmB;IAU9B,YACmB,IAAiB,EACjB,QAAyB,EAC1C,IAA0B;QAFT,SAAI,GAAJ,IAAI,CAAa;QACjB,aAAQ,GAAR,QAAQ,CAAiB;QAPpC,YAAO,GAAG,IAAI,CAAC;QACf,aAAQ,GAAG,KAAK,CAAC;QACjB,WAAM,GAAG,CAAC,CAAC;QACX,eAAU,GAAG,CAAC,CAAC;QAyEN,kBAAa,GAAG,CAAC,CAAe,EAAQ,EAAE;YACzD,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,CAAC,CAAC,eAAe,EAAE,CAAC;YACpB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC;YACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACvC,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC,CAAC;QAEe,kBAAa,GAAG,CAAC,CAAe,EAAQ,EAAE;YACzD,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAC3B,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,CAAC,CAAC,eAAe,EAAE,CAAC;YACpB,iGAAiG;YACjG,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;YACnC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAC5D,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC;YAClG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC,CAAC;QAEe,gBAAW,GAAG,CAAC,CAAe,EAAQ,EAAE;YACvD,IAAI,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO;YAC3B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;gBAAE,IAAI,CAAC,EAAE,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC7F,CAAC,CAAC;QAEe,kBAAa,GAAG,CAAC,CAAa,EAAQ,EAAE;YACvD,CAAC,CAAC,cAAc,EAAE,CAAC;YACnB,CAAC,CAAC,eAAe,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACtB,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,CAAC,CAAC;QAlGA,IAAI,CAAC,IAAI,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,IAAI,EAAE,CAAC;QACrC,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ;YAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;QAEnF,IAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE;YAC3B,QAAQ,EAAE,UAAU;YACpB,MAAM,EAAE,IAAI;YACZ,KAAK,EAAE,MAAM;YACb,MAAM,EAAE,MAAM;YACd,UAAU,EAAE,OAAO;YACnB,SAAS,EAAE,OAAO;YAClB,YAAY,EAAE,KAAK;YACnB,UAAU,EAAE,wBAAwB,EAAE,sCAAsC;YAC5E,MAAM,EAAE,kBAAkB;YAC1B,SAAS,EAAE,yBAAyB;YACpC,KAAK,EAAE,MAAM;YACb,IAAI,EAAE,iBAAiB;YACvB,UAAU,EAAE,MAAM;YAClB,SAAS,EAAE,QAAQ;YACnB,MAAM,EAAE,WAAW;YACnB,WAAW,EAAE,MAAM;YACnB,UAAU,EAAE,MAAM;SACa,CAAC,CAAC;QACnC,IAAI,CAAC,EAAE,CAAC,WAAW,GAAG,GAAG,CAAC;QAC1B,IAAI,CAAC,EAAE,CAAC,KAAK,GAAG,8DAA8D,CAAC;QAC/E,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAE/B,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QACxD,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5D,IAAI,CAAC,EAAE,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAEzD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAC/E,IAAI,OAAO,cAAc,KAAK,WAAW,EAAE,CAAC;YAC1C,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YAClE,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,UAAU,CAAC,OAAgB;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED;wFACoF;IACpF,UAAU;QACR,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;QACjC,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YAC/B,OAAO;QACT,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACjD,MAAM,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;YAC/B,OAAO;QACT,CAAC;QACD,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;QAC3B,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;QAChC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;IACjC,CAAC;IAoCD,OAAO;QACL,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,cAAc,EAAE,UAAU,EAAE,CAAC;QAClC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC3D,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC/D,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC5D,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;CACF","sourcesContent":["/**\n * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn\n * over the 3D canvas at the projected top-face centre of the volume box (projected with napari-js's\n * {@link projectPoint}, as the axes labels are, so it tracks the box as the volume orbits). Dragging it up makes\n * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and\n * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).\n *\n * Direct-manipulation counterpart of napari-js's `AxesLabelsOverlay`: both are absolute-positioned\n * overlays updated on every `camera3d.changed`, but this one accepts pointer input.\n */\nimport { projectPoint } from 'napari-js';\n\n/** The slice of napari's Camera3D the handle reads. `viewProjection` is column-major (gl-matrix). */\nexport interface ZHandleCamera3D {\n  viewProjection(vw: number, vh: number): ArrayLike<number>;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\nexport interface VolumeZHandleOptions {\n  /** Current top-face-centre world point (the box is centred at the origin, so `[0, 0, +halfZ]`). */\n  topAnchor: () => [number, number, number];\n  /** The current Z-scale factor (1 = the volume's default proportions). */\n  getScale: () => number;\n  /** Apply a new Z-scale factor — the host restretches the volume + axes and repositions overlays. */\n  setScale: (scale: number) => void;\n  /** Vertical drag (px) for one doubling/halving of the Z height. Larger = less sensitive. */\n  pixelsPerDouble?: number;\n  /** Clamp for the Z-scale factor. */\n  minScale?: number;\n  maxScale?: number;\n}\n\nconst DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };\n\nexport class NapariVolumeZHandle {\n  private readonly el: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private readonly opts: Required<VolumeZHandleOptions>;\n  private visible = true;\n  private dragging = false;\n  private startY = 0;\n  private startScale = 1;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: ZHandleCamera3D,\n    opts: VolumeZHandleOptions,\n  ) {\n    this.opts = { ...DEFAULTS, ...opts };\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      zIndex: '31',\n      width: '22px',\n      height: '22px',\n      marginLeft: '-11px',\n      marginTop: '-11px',\n      borderRadius: '50%',\n      background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)\n      border: '1.5px solid #fff',\n      boxShadow: '0 0 4px rgba(0,0,0,0.6)',\n      color: '#fff',\n      font: '13px sans-serif',\n      lineHeight: '20px',\n      textAlign: 'center',\n      cursor: 'ns-resize',\n      touchAction: 'none',\n      userSelect: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.el.textContent = '↕';\n    this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';\n    this.host.appendChild(this.el);\n\n    this.el.addEventListener('pointerdown', this.onPointerDown);\n    this.el.addEventListener('pointermove', this.onPointerMove);\n    this.el.addEventListener('pointerup', this.onPointerUp);\n    this.el.addEventListener('pointercancel', this.onPointerUp);\n    this.el.addEventListener('dblclick', this.onDoubleClick);\n\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.reposition());\n      this.resizeObserver.observe(this.host);\n    }\n    this.reposition();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.reposition();\n  }\n\n  /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after\n   *  the host applies a new scale (so the grip follows the growing/shrinking box). */\n  reposition(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      this.el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);\n    if (!s.visible) {\n      this.el.style.display = 'none';\n      return;\n    }\n    this.el.style.display = '';\n    this.el.style.left = `${s.x}px`;\n    this.el.style.top = `${s.y}px`;\n  }\n\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.dragging = true;\n    this.startY = e.clientY;\n    this.startScale = this.opts.getScale();\n    this.el.setPointerCapture?.(e.pointerId);\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    e.preventDefault();\n    e.stopPropagation();\n    // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.\n    const dy = e.clientY - this.startY;\n    const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);\n    const next = Math.min(this.opts.maxScale, Math.max(this.opts.minScale, this.startScale * factor));\n    this.opts.setScale(next);\n    this.reposition();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    this.dragging = false;\n    if (this.el.hasPointerCapture?.(e.pointerId)) this.el.releasePointerCapture?.(e.pointerId);\n  };\n\n  private readonly onDoubleClick = (e: MouseEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.opts.setScale(1);\n    this.reposition();\n  };\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.el.removeEventListener('pointerdown', this.onPointerDown);\n    this.el.removeEventListener('pointermove', this.onPointerMove);\n    this.el.removeEventListener('pointerup', this.onPointerUp);\n    this.el.removeEventListener('pointercancel', this.onPointerUp);\n    this.el.removeEventListener('dblclick', this.onDoubleClick);\n    this.el.parentNode?.removeChild(this.el);\n  }\n}\n"]}