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

package/esm2022/lib/implementations/napari-js/napari-helpers.mjs

@@ -0,0 +1,199 @@
+import { NAPARI_DEFAULT_DECIMATE } from '../../contracts/plot-type';
+/**
+ * Pure helpers and constants of the napari-js backend: no viewer, no store, no network. Shared by
+ * the service and its scenes (review Appendix B, step 1).
+ */
+/**
+ * A short, stable id for a colormap value, for cache keys.
+ *
+ * Half the library's colormaps are NAMES and half are inline `[stop, colour]`
+ * arrays of 256 entries. Stringifying the array kind would put 6 KB in a key that
+ * is rebuilt and compared on every view change; hashing it keeps the key small,
+ * and it only has to distinguish one colormap from another.
+ */
+export function colormapId(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '?';
+    // FNV-1a over the stops. A collision would leave a stale colouring on screen,
+    // not corrupt anything, and 32 bits over a few hundred colormaps will not.
+    let hash = 0x811c9dc5;
+    const text = value.map((stop) => String(stop)).join(',');
+    for (let i = 0; i < text.length; i++) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `#${(hash >>> 0).toString(36)}`;
+}
+export const VOLUME_MAX_SLICE = 1024; // "Full" in-plane cap; the default ¼ load uses 256
+/** Reference in-plane world size (long side) for the volume/axes box, in arbitrary world units.
+ *  The box is anchored to this reference regardless of the chosen decimate factor, so changing the
+ *  resolution changes DETAIL, not the volume's proportions (Z no longer appears to shrink when the
+ *  in-plane sampling grows). Set to the DEFAULT decimate's in-plane cap so the default view is
+ *  unchanged; higher/lower resolutions keep that same shape. */
+export const VOLUME_WORLD_INPLANE_REF = VOLUME_MAX_SLICE / NAPARI_DEFAULT_DECIMATE;
+/** Max concurrent slice fetches when assembling a volume — keeps the connection pool busy
+ *  without flooding it (browsers cap ~6/host) on a deep stack. */
+export const VOLUME_FETCH_CONCURRENCY = 8;
+/** Volume/isosurface sampling for a decimate factor `scale` (1 = Full 1024, 2 = ½ 512, 4 = ¼ 256
+ *  default, 8 = ⅛ 128): the in-plane cap halves each step; slices stay un-subsampled until ⅛, then
+ *  subsample. */
+export function volumeResolutionFor(scale) {
+    const s = Math.max(1, Math.round(scale));
+    return {
+        maxSlice: Math.max(8, Math.round(VOLUME_MAX_SLICE / s)),
+        sliceStep: Math.max(1, Math.floor(s / 4)),
+    };
+}
+/** Fully-normalized intensity height as a fraction of the in-plane extent — matches the Plotly
+ *  SURFACE z-aspect (~0.4) so the relief isn't exaggerated. */
+export const SURFACE_Z_ASPECT = 0.4;
+/** "Full" mesh grid cap; the decimate factor divides it (default ¼ → 220, ½ → 440, Full → 880). */
+export const SURFACE_MAX_GRID = 880;
+/** Coefficient scaling the pyramid tile budget with the target resolution — a higher target pulls a
+ *  finer pyramid level (more real detail). Shared by the surface plane fetch + volume assembly. */
+export const STITCH_BUDGET_COEFF = 16;
+/** Surface mesh target grid for a decimate factor `scale`: the grid cap shrinks by `scale` (every
+ *  slice is kept — the z-slider needs them all). The source is fetched at a matching resolution. */
+export function surfaceResolutionFor(scale) {
+    const s = Math.max(1, Math.round(scale));
+    return { maxGrid: Math.max(16, Math.round(SURFACE_MAX_GRID / s)) };
+}
+/** 3D scatter: in-plane cap for the assembled voxel grid, and the max number of points emitted
+ *  (the grid is flat-strided down to this) — keeps the billboard count interactive. */
+export const SCATTER3D_MAX_XY = 64;
+export const SCATTER3D_MAX_POINTS = 150000;
+/** How long a pan/zoom must settle before the viewport (and, for pixel tools, the canvas
+ *  readback) is refreshed — coalesces the camera's per-frame changes. */
+export const READBACK_DEBOUNCE_MS = 250;
+export const TILE_SIZE = 512; // server tile edge (matches the OSD backend)
+/** Max tiles stitched for one displayed slice (512px tiles → up to ~6144² at full res). Beyond
+ *  this we step to a coarser pyramid level so a large image stays tractable. */
+export const MAX_STITCH_TILES = 144;
+/** WebGPU default `maxTextureDimension2D` — a stitched slice's longest side must fit a texture. */
+export const MAX_TEXTURE_DIM = 8192;
+/** Concurrent tile requests per stitched slice. Firing a whole grid at once (hundreds of requests
+ *  for a large level) overwhelmed the tile server (504s); a small pool keeps the pipe full without
+ *  flooding it — and slice-level workers already run several stitches in parallel on top of this. */
+export const TILE_FETCH_CONCURRENCY = 6;
+/** Split RGB tiles kept for a band that asks after the other two (see
+ *  `NapariTileClient.rgbBandSources`): ~3 × 256 KB per 512px tile. */
+export const RGB_BAND_CACHE_TILES = 16;
+/** How long to poll `/tiles/info` (202 while the server caches the source) before falling back to
+ *  a single tile. Generous like the OSD backend — a cold whole-slide can take minutes to cache. */
+export const DESCRIPTOR_TIMEOUT_MS = 120000;
+/** Wait between two `/tiles/info` polls while the server answers 202. */
+export const DESCRIPTOR_POLL_INTERVAL_MS = 1200;
+/**
+ * `IChannelState.gamma` → the `gamma` a napari-js layer or view takes.
+ *
+ * The shared channel state follows the ImageJ/Fiji convention the OSD backend draws
+ * (`osd/display-pipeline.ts`: output = t^(1/γ), so γ > 1 BRIGHTENS the midtones), while
+ * napari-js's shaders apply `pow(t, gamma)` (napari's convention: γ > 1 darkens). Every gamma
+ * handed to napari-js goes through here, so one slider in the Channels & Histogram dialog moves
+ * both backends the same way. Both backends apply window → invert → gamma, per channel before
+ * an additive merge (NAPARI-BOUNDARY-2; pinned by `osd/display-pipeline.cross-backend.spec.ts`).
+ */
+export function toNapariGamma(gamma) {
+    return gamma != null && gamma > 0 ? 1 / gamma : 1;
+}
+/** A 2D canvas (an `OffscreenCanvas` where available) and its context; throws, naming `what`,
+ *  when no 2D context can be had. */
+export function create2dCanvas(width, height, what) {
+    let canvas;
+    if (typeof OffscreenCanvas !== 'undefined') {
+        canvas = new OffscreenCanvas(width, height);
+    }
+    else {
+        canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+    }
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        throw new Error(`[napari-js] ${what}: 2D context unavailable`);
+    return { canvas, ctx };
+}
+/**
+ * Run `fn` over `items` with at most `concurrency` in flight — keeps the connection pool busy
+ * without flooding the server — starting no further item once `stop()` says so.
+ */
+export async function mapPool(items, concurrency, fn, stop = () => false) {
+    let next = 0;
+    const worker = async () => {
+        while (next < items.length && !stop())
+            await fn(items[next++]);
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));
+}
+/** A serverless multichannel stack (`tiled:false` + `channelUrls`): no tile descriptor, so its
+ *  channel count comes from `imageMeta`, and each band is fetched from its own plane URLs. */
+export function isServerlessMultichannel(simple, info) {
+    return simple && !!info?.channelUrls?.length && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;
+}
+/** The stack's declared slice count (`imageMeta.z`, else one URL per slice); 0 when unknown. */
+export function stackDepth(info) {
+    return info?.imageMeta?.[0]?.z || info?.urls?.length || 0;
+}
+/** The R, G and B bands of RGBA8 pixels as three uint8 planes (alpha dropped). */
+export function splitRgbBands(px) {
+    const n = px.width * px.height;
+    const bands = [new Uint8Array(n), new Uint8Array(n), new Uint8Array(n)];
+    const [r, g, b] = bands;
+    const d = px.data;
+    for (let i = 0, o = 0; i < n; i++, o += 4) {
+        r[i] = d[o];
+        g[i] = d[o + 1];
+        b[i] = d[o + 2];
+    }
+    return bands.map((data) => ({ data, width: px.width, height: px.height }));
+}
+/** A decoded single-channel uint8 plane as a napari-js typed image source. */
+export function typedPlane(d) {
+    return { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data };
+}
+/** Default per-channel tints (Fiji-style) when the store/descriptor offers no colour. */
+const DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff', '#ffffff'];
+/** Default tint for a channel index, cycling the Fiji palette. */
+export function tintFor(channel) {
+    return DEFAULT_TINTS[channel % DEFAULT_TINTS.length];
+}
+/** Convert a napari-js `Histogram` (bin count + min/max) to the pane's `IHistogram` (bin edges). */
+export function toIHistogram(h) {
+    const span = h.max - h.min || 1;
+    const bins = Array.from({ length: h.bins }, (_, i) => h.min + (i * span) / h.bins);
+    const counts = Array.from(h.counts);
+    return { bins, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };
+}
+/**
+ * Additively composite grayscale channel images, each tinted with its display colour —
+ * the navigator's picture of a multichannel image.
+ */
+export function tintedComposite(images, colors) {
+    const w = images[0]?.width ?? 1;
+    const h = images[0]?.height ?? 1;
+    const out = document.createElement('canvas');
+    out.width = w;
+    out.height = h;
+    const ctx = out.getContext('2d');
+    ctx.fillStyle = '#000';
+    ctx.fillRect(0, 0, w, h);
+    const tmp = document.createElement('canvas');
+    tmp.width = w;
+    tmp.height = h;
+    const t = tmp.getContext('2d');
+    images.forEach((img, i) => {
+        t.globalCompositeOperation = 'source-over';
+        t.drawImage(img, 0, 0, w, h);
+        t.globalCompositeOperation = 'multiply';
+        t.fillStyle = colors[i];
+        t.fillRect(0, 0, w, h);
+        ctx.globalCompositeOperation = 'lighter';
+        ctx.drawImage(tmp, 0, 0);
+    });
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-helpers.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;GAGG;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,EAAE,CAAC;IAC7B,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IACtC,8EAA8E;IAC9E,2EAA2E;IAC3E,IAAI,IAAI,GAAG,UAAU,CAAC;IACtB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC3B,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;AACzC,CAAC;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC,CAAC,mDAAmD;AACzF;;;;gEAIgE;AAChE,MAAM,CAAC,MAAM,wBAAwB,GAAG,gBAAgB,GAAG,uBAAuB,CAAC;AACnF;kEACkE;AAClE,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C;;iBAEiB;AACjB,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,OAAO;QACL,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;QACvD,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;KAC1C,CAAC;AACJ,CAAC;AACD;+DAC+D;AAC/D,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AACpC,mGAAmG;AACnG,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AACpC;mGACmG;AACnG,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AACtC;oGACoG;AACpG,MAAM,UAAU,oBAAoB,CAAC,KAAa;IAChD,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AACrE,CAAC;AAED;uFACuF;AACvF,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AACnC,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAE3C;yEACyE;AACzE,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAExC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC,CAAC,6CAA6C;AAC3E;gFACgF;AAChF,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AACpC,mGAAmG;AACnG,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAC;AACpC;;qGAEqG;AACrG,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACxC;sEACsE;AACtE,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,CAAC;AACvC;mGACmG;AACnG,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAC5C,yEAAyE;AACzE,MAAM,CAAC,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAShD;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,KAAyB;IACrD,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AACpD,CAAC;AAED;qCACqC;AACrC,MAAM,UAAU,cAAc,CAC5B,KAAa,EACb,MAAc,EACd,IAAY;IAKZ,IAAI,MAA2C,CAAC;IAChD,IAAI,OAAO,eAAe,KAAK,WAAW,EAAE,CAAC;QAC3C,MAAM,GAAG,IAAI,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;QACrB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAwE,CAAC;IAC3G,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,KAAK,CAAC,eAAe,IAAI,0BAA0B,CAAC,CAAC;IACzE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;AACzB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,KAAmB,EACnB,WAAmB,EACnB,EAA8B,EAC9B,OAAsB,GAAG,EAAE,CAAC,KAAK;IAEjC,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,MAAM,GAAG,KAAK,IAAmB,EAAE;QACvC,OAAO,IAAI,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE;YAAE,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACjE,CAAC,CAAC;IACF,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AACjG,CAAC;AAED;8FAC8F;AAC9F,MAAM,UAAU,wBAAwB,CAAC,MAAe,EAAE,IAA4B;IACpF,OAAO,MAAM,IAAI,CAAC,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AAChG,CAAC;AAED,gGAAgG;AAChG,MAAM,UAAU,UAAU,CAAC,IAA4B;IACrD,OAAO,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC;AAC5D,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,aAAa,CAAC,EAA8D;IAC1F,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,MAAM,CAAC;IAC/B,MAAM,KAAK,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;IACxB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAC7E,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,UAAU,CAAC,CAAY;IACrC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AACxG,CAAC;AAED,yFAAyF;AACzF,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AAEpG,kEAAkE;AAClE,MAAM,UAAU,OAAO,CAAC,OAAe;IACrC,OAAO,aAAa,CAAC,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AACvD,CAAC;AAED,oGAAoG;AACpG,MAAM,UAAU,YAAY,CAAC,CAAkE;IAC7F,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;IACnF,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;AAC5E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAoE,EACpE,MAAgB;IAEhB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC;IAChC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC7C,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;IACd,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IACf,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAE,CAAC;IAClC,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC;IACvB,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACzB,MAAM,GAAG,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC7C,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;IACd,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC;IACf,MAAM,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,IAAI,CAAE,CAAC;IAChC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;QACxB,CAAC,CAAC,wBAAwB,GAAG,aAAa,CAAC;QAC3C,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC7B,CAAC,CAAC,wBAAwB,GAAG,UAAU,CAAC;QACxC,CAAC,CAAC,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvB,GAAG,CAAC,wBAAwB,GAAG,SAAS,CAAC;QACzC,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3B,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { ChannelView } from 'napari-js';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { NAPARI_DEFAULT_DECIMATE } from '../../contracts/plot-type';\n\n/**\n * Pure helpers and constants of the napari-js backend: no viewer, no store, no network. Shared by\n * the service and its scenes (review Appendix B, step 1).\n */\n\n/**\n * A short, stable id for a colormap value, for cache keys.\n *\n * Half the library's colormaps are NAMES and half are inline `[stop, colour]`\n * arrays of 256 entries. Stringifying the array kind would put 6 KB in a key that\n * is rebuilt and compared on every view change; hashing it keeps the key small,\n * and it only has to distinguish one colormap from another.\n */\nexport function colormapId(value: unknown): string {\n  if (value == null) return '';\n  if (typeof value === 'string') return value;\n  if (!Array.isArray(value)) return '?';\n  // FNV-1a over the stops. A collision would leave a stale colouring on screen,\n  // not corrupt anything, and 32 bits over a few hundred colormaps will not.\n  let hash = 0x811c9dc5;\n  const text = value.map((stop) => String(stop)).join(',');\n  for (let i = 0; i < text.length; i++) {\n    hash ^= text.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return `#${(hash >>> 0).toString(36)}`;\n}\n\nexport const VOLUME_MAX_SLICE = 1024; // \"Full\" in-plane cap; the default ¼ load uses 256\n/** Reference in-plane world size (long side) for the volume/axes box, in arbitrary world units.\n *  The box is anchored to this reference regardless of the chosen decimate factor, so changing the\n *  resolution changes DETAIL, not the volume's proportions (Z no longer appears to shrink when the\n *  in-plane sampling grows). Set to the DEFAULT decimate's in-plane cap so the default view is\n *  unchanged; higher/lower resolutions keep that same shape. */\nexport const VOLUME_WORLD_INPLANE_REF = VOLUME_MAX_SLICE / NAPARI_DEFAULT_DECIMATE;\n/** Max concurrent slice fetches when assembling a volume — keeps the connection pool busy\n *  without flooding it (browsers cap ~6/host) on a deep stack. */\nexport const VOLUME_FETCH_CONCURRENCY = 8;\n\n/** Volume/isosurface sampling for a decimate factor `scale` (1 = Full 1024, 2 = ½ 512, 4 = ¼ 256\n *  default, 8 = ⅛ 128): the in-plane cap halves each step; slices stay un-subsampled until ⅛, then\n *  subsample. */\nexport function volumeResolutionFor(scale: number): { maxSlice: number; sliceStep: number } {\n  const s = Math.max(1, Math.round(scale));\n  return {\n    maxSlice: Math.max(8, Math.round(VOLUME_MAX_SLICE / s)),\n    sliceStep: Math.max(1, Math.floor(s / 4)),\n  };\n}\n/** Fully-normalized intensity height as a fraction of the in-plane extent — matches the Plotly\n *  SURFACE z-aspect (~0.4) so the relief isn't exaggerated. */\nexport const SURFACE_Z_ASPECT = 0.4;\n/** \"Full\" mesh grid cap; the decimate factor divides it (default ¼ → 220, ½ → 440, Full → 880). */\nexport const SURFACE_MAX_GRID = 880;\n/** Coefficient scaling the pyramid tile budget with the target resolution — a higher target pulls a\n *  finer pyramid level (more real detail). Shared by the surface plane fetch + volume assembly. */\nexport const STITCH_BUDGET_COEFF = 16;\n/** Surface mesh target grid for a decimate factor `scale`: the grid cap shrinks by `scale` (every\n *  slice is kept — the z-slider needs them all). The source is fetched at a matching resolution. */\nexport function surfaceResolutionFor(scale: number): { maxGrid: number } {\n  const s = Math.max(1, Math.round(scale));\n  return { maxGrid: Math.max(16, Math.round(SURFACE_MAX_GRID / s)) };\n}\n\n/** 3D scatter: in-plane cap for the assembled voxel grid, and the max number of points emitted\n *  (the grid is flat-strided down to this) — keeps the billboard count interactive. */\nexport const SCATTER3D_MAX_XY = 64;\nexport const SCATTER3D_MAX_POINTS = 150000;\n\n/** How long a pan/zoom must settle before the viewport (and, for pixel tools, the canvas\n *  readback) is refreshed — coalesces the camera's per-frame changes. */\nexport const READBACK_DEBOUNCE_MS = 250;\n\nexport const TILE_SIZE = 512; // server tile edge (matches the OSD backend)\n/** Max tiles stitched for one displayed slice (512px tiles → up to ~6144² at full res). Beyond\n *  this we step to a coarser pyramid level so a large image stays tractable. */\nexport const MAX_STITCH_TILES = 144;\n/** WebGPU default `maxTextureDimension2D` — a stitched slice's longest side must fit a texture. */\nexport const MAX_TEXTURE_DIM = 8192;\n/** Concurrent tile requests per stitched slice. Firing a whole grid at once (hundreds of requests\n *  for a large level) overwhelmed the tile server (504s); a small pool keeps the pipe full without\n *  flooding it — and slice-level workers already run several stitches in parallel on top of this. */\nexport const TILE_FETCH_CONCURRENCY = 6;\n/** Split RGB tiles kept for a band that asks after the other two (see\n *  `NapariTileClient.rgbBandSources`): ~3 × 256 KB per 512px tile. */\nexport const RGB_BAND_CACHE_TILES = 16;\n/** How long to poll `/tiles/info` (202 while the server caches the source) before falling back to\n *  a single tile. Generous like the OSD backend — a cold whole-slide can take minutes to cache. */\nexport const DESCRIPTOR_TIMEOUT_MS = 120000;\n/** Wait between two `/tiles/info` polls while the server answers 202. */\nexport const DESCRIPTOR_POLL_INTERVAL_MS = 1200;\n\n/** A decoded single-channel uint8 plane. */\nexport interface LumaPlane {\n  data: Uint8Array;\n  width: number;\n  height: number;\n}\n\n/**\n * `IChannelState.gamma` → the `gamma` a napari-js layer or view takes.\n *\n * The shared channel state follows the ImageJ/Fiji convention the OSD backend draws\n * (`osd/display-pipeline.ts`: output = t^(1/γ), so γ > 1 BRIGHTENS the midtones), while\n * napari-js's shaders apply `pow(t, gamma)` (napari's convention: γ > 1 darkens). Every gamma\n * handed to napari-js goes through here, so one slider in the Channels & Histogram dialog moves\n * both backends the same way. Both backends apply window → invert → gamma, per channel before\n * an additive merge (NAPARI-BOUNDARY-2; pinned by `osd/display-pipeline.cross-backend.spec.ts`).\n */\nexport function toNapariGamma(gamma: number | undefined): number {\n  return gamma != null && gamma > 0 ? 1 / gamma : 1;\n}\n\n/** A 2D canvas (an `OffscreenCanvas` where available) and its context; throws, naming `what`,\n *  when no 2D context can be had. */\nexport function create2dCanvas(\n  width: number,\n  height: number,\n  what: string,\n): {\n  canvas: HTMLCanvasElement | OffscreenCanvas;\n  ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;\n} {\n  let canvas: HTMLCanvasElement | OffscreenCanvas;\n  if (typeof OffscreenCanvas !== 'undefined') {\n    canvas = new OffscreenCanvas(width, height);\n  } else {\n    canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n  }\n  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;\n  if (!ctx) throw new Error(`[napari-js] ${what}: 2D context unavailable`);\n  return { canvas, ctx };\n}\n\n/**\n * Run `fn` over `items` with at most `concurrency` in flight — keeps the connection pool busy\n * without flooding the server — starting no further item once `stop()` says so.\n */\nexport async function mapPool<T>(\n  items: readonly T[],\n  concurrency: number,\n  fn: (item: T) => Promise<void>,\n  stop: () => boolean = () => false,\n): Promise<void> {\n  let next = 0;\n  const worker = async (): Promise<void> => {\n    while (next < items.length && !stop()) await fn(items[next++]);\n  };\n  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()));\n}\n\n/** A serverless multichannel stack (`tiled:false` + `channelUrls`): no tile descriptor, so its\n *  channel count comes from `imageMeta`, and each band is fetched from its own plane URLs. */\nexport function isServerlessMultichannel(simple: boolean, info: IImageInfo | undefined): boolean {\n  return simple && !!info?.channelUrls?.length && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1;\n}\n\n/** The stack's declared slice count (`imageMeta.z`, else one URL per slice); 0 when unknown. */\nexport function stackDepth(info: IImageInfo | undefined): number {\n  return info?.imageMeta?.[0]?.z || info?.urls?.length || 0;\n}\n\n/** The R, G and B bands of RGBA8 pixels as three uint8 planes (alpha dropped). */\nexport function splitRgbBands(px: { data: ArrayLike<number>; width: number; height: number }): LumaPlane[] {\n  const n = px.width * px.height;\n  const bands = [new Uint8Array(n), new Uint8Array(n), new Uint8Array(n)];\n  const [r, g, b] = bands;\n  const d = px.data;\n  for (let i = 0, o = 0; i < n; i++, o += 4) {\n    r[i] = d[o];\n    g[i] = d[o + 1];\n    b[i] = d[o + 2];\n  }\n  return bands.map((data) => ({ data, width: px.width, height: px.height }));\n}\n\n/** A decoded single-channel uint8 plane as a napari-js typed image source. */\nexport function typedPlane(d: LumaPlane): ChannelView['source'] {\n  return { kind: 'typed', width: d.width, height: d.height, channels: 1, dtype: 'uint8', data: d.data };\n}\n\n/** Default per-channel tints (Fiji-style) when the store/descriptor offers no colour. */\nconst DEFAULT_TINTS = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff', '#ffffff'];\n\n/** Default tint for a channel index, cycling the Fiji palette. */\nexport function tintFor(channel: number): string {\n  return DEFAULT_TINTS[channel % DEFAULT_TINTS.length];\n}\n\n/** Convert a napari-js `Histogram` (bin count + min/max) to the pane's `IHistogram` (bin edges). */\nexport function toIHistogram(h: { counts: Uint32Array; bins: number; min: number; max: number }): IHistogram {\n  const span = h.max - h.min || 1;\n  const bins = Array.from({ length: h.bins }, (_, i) => h.min + (i * span) / h.bins);\n  const counts = Array.from(h.counts);\n  return { bins, counts, max: counts.reduce((m, c) => (c > m ? c : m), 0) };\n}\n\n/**\n * Additively composite grayscale channel images, each tinted with its display colour —\n * the navigator's picture of a multichannel image.\n */\nexport function tintedComposite(\n  images: Array<CanvasImageSource & { width: number; height: number }>,\n  colors: string[],\n): HTMLCanvasElement {\n  const w = images[0]?.width ?? 1;\n  const h = images[0]?.height ?? 1;\n  const out = document.createElement('canvas');\n  out.width = w;\n  out.height = h;\n  const ctx = out.getContext('2d')!;\n  ctx.fillStyle = '#000';\n  ctx.fillRect(0, 0, w, h);\n  const tmp = document.createElement('canvas');\n  tmp.width = w;\n  tmp.height = h;\n  const t = tmp.getContext('2d')!;\n  images.forEach((img, i) => {\n    t.globalCompositeOperation = 'source-over';\n    t.drawImage(img, 0, 0, w, h);\n    t.globalCompositeOperation = 'multiply';\n    t.fillStyle = colors[i];\n    t.fillRect(0, 0, w, h);\n    ctx.globalCompositeOperation = 'lighter';\n    ctx.drawImage(tmp, 0, 0);\n  });\n  return out;\n}\n"]}