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

package/esm2022/lib/implementations/plotly/plotly-coordinate-transform.mjs

@@ -34,4 +34,4 @@ export class PlotlyCoordinateTransform {
         return Math.abs(xaxis.l2p(dataLength) - xaxis.l2p(0));
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxvdGx5LWNvb3JkaW5hdGUtdHJhbnNmb3JtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9pbXBsZW1lbnRhdGlvbnMvcGxvdGx5L3Bsb3RseS1jb29yZGluYXRlLXRyYW5zZm9ybS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyx5QkFBeUI7SUFFcEMsWUFDVSxXQUFzQixFQUN0QixZQUFzQztRQUR0QyxnQkFBVyxHQUFYLFdBQVcsQ0FBVztRQUN0QixpQkFBWSxHQUFaLFlBQVksQ0FBMEI7SUFDN0MsQ0FBQztJQUVJLElBQUk7UUFDVixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsV0FBVyxFQUFFLEVBQUUsV0FBVyxDQUFDO1FBQy9DLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDO0lBQ3hELENBQUM7SUFFRCxPQUFPO1FBQ0wsTUFBTSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDckMsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUFLLElBQUksS0FBSyxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVELFlBQVksQ0FBQyxPQUFlLEVBQUUsT0FBZTtRQUMzQyxNQUFNLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNyQyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsWUFBWSxFQUFFLEVBQUUscUJBQXFCLEVBQUUsQ0FBQztRQUMxRCxJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsSUFBSTtZQUFFLE9BQU8sRUFBRSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsQ0FBQztRQUN6RCxPQUFPO1lBQ0wsQ0FBQyxFQUFFLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxJQUFJLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQztZQUNqRCxDQUFDLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEdBQUcsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDO1NBQ2pELENBQUM7SUFDSixDQUFDO0lBRUQsa0JBQWtCLENBQUMsVUFBa0I7UUFDbkMsTUFBTSxFQUFFLEtBQUssRUFBRSxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUM5QixJQUFJLENBQUMsS0FBSztZQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN4RCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJQ29vcmRpbmF0ZVRyYW5zZm9ybSB9IGZyb20gJy4uLy4uL2NvbnRyYWN0cy9jb29yZGluYXRlLXRyYW5zZm9ybS5jb250cmFjdCc7XG5cbi8qKlxuICogUGxvdGx5IGltcGxlbWVudGF0aW9uIG9mIHtAbGluayBJQ29vcmRpbmF0ZVRyYW5zZm9ybX0uIFdyYXBzIHRoZSBheGlzIG9iamVjdHNcbiAqIG9uIHRoZSBwbG90J3MgYF9mdWxsTGF5b3V0YC4gVGhpcyBpcyB0aGUgZXhhY3QgbWF0aCB0aGUgd2FuZCAvIHZlcnRleC1lcmFzZXJcbiAqIHVzZWQgaW5saW5lIGJlZm9yZSB0aGV5IHdlcmUgZGVjb3VwbGVkIOKAlCBsaWZ0ZWQgaGVyZSB2ZXJiYXRpbSBzbyBQbG90bHlcbiAqIGJlaGF2aW91ciBpcyB1bmNoYW5nZWQuXG4gKi9cbmV4cG9ydCBjbGFzcyBQbG90bHlDb29yZGluYXRlVHJhbnNmb3JtIGltcGxlbWVudHMgSUNvb3JkaW5hdGVUcmFuc2Zvcm0ge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgZ2V0R3JhcGhEaXY6ICgpID0+IGFueSxcbiAgICBwcml2YXRlIGdldENvbnRhaW5lcjogKCkgPT4gSFRNTEVsZW1lbnQgfCBudWxsLFxuICApIHt9XG5cbiAgcHJpdmF0ZSBheGVzKCk6IHsgeGF4aXM6IGFueTsgeWF4aXM6IGFueSB9IHtcbiAgICBjb25zdCBsYXlvdXQgPSB0aGlzLmdldEdyYXBoRGl2KCk/Ll9mdWxsTGF5b3V0O1xuICAgIHJldHVybiB7IHhheGlzOiBsYXlvdXQ/LnhheGlzLCB5YXhpczogbGF5b3V0Py55YXhpcyB9O1xuICB9XG5cbiAgaXNSZWFkeSgpOiBib29sZWFuIHtcbiAgICBjb25zdCB7IHhheGlzLCB5YXhpcyB9ID0gdGhpcy5heGVzKCk7XG4gICAgcmV0dXJuICEhKHhheGlzICYmIHlheGlzKTtcbiAgfVxuXG4gIGNsaWVudFRvRGF0YShjbGllbnRYOiBudW1iZXIsIGNsaWVudFk6IG51bWJlcik6IHsgeDogbnVtYmVyOyB5OiBudW1iZXIgfSB7XG4gICAgY29uc3QgeyB4YXhpcywgeWF4aXMgfSA9IHRoaXMuYXhlcygpO1xuICAgIGNvbnN0IHJlY3QgPSB0aGlzLmdldENvbnRhaW5lcigpPy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKTtcbiAgICBpZiAoIXhheGlzIHx8ICF5YXhpcyB8fCAhcmVjdCkgcmV0dXJuIHsgeDogTmFOLCB5OiBOYU4gfTtcbiAgICByZXR1cm4ge1xuICAgICAgeDogeGF4aXMucDJkKGNsaWVudFggLSByZWN0LmxlZnQgLSB4YXhpcy5fb2Zmc2V0KSxcbiAgICAgIHk6IHlheGlzLnAyZChjbGllbnRZIC0gcmVjdC50b3AgLSB5YXhpcy5fb2Zmc2V0KSxcbiAgICB9O1xuICB9XG5cbiAgZGF0YUxlbmd0aFRvU2NyZWVuKGRhdGFMZW5ndGg6IG51bWJlcik6IG51bWJlciB7XG4gICAgY29uc3QgeyB4YXhpcyB9ID0gdGhpcy5heGVzKCk7XG4gICAgaWYgKCF4YXhpcykgcmV0dXJuIDA7XG4gICAgcmV0dXJuIE1hdGguYWJzKHhheGlzLmwycChkYXRhTGVuZ3RoKSAtIHhheGlzLmwycCgwKSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/plotly/plotly-image-loader.mjs

@@ -0,0 +1,112 @@
+import { BehaviorSubject } from 'rxjs';
+import { Image } from 'image-js';
+import { Buffer } from 'buffer';
+import { PlotUtilities } from '../../plot.utilities';
+import { firstValueFromAbortable, throwIfAborted } from '../tile-server/transport';
+import { channelPlaneUrls } from './plotly-image-recolor';
+/** Parallel slice fetches when loading a stack (cf. napari's volume fetch pool). */
+const PLOTLY_STACK_FETCH_CONCURRENCY = 4;
+/**
+ * Plotly's image source: fetches slices through HttpClient (so the auth
+ * interceptors apply — a raw fetch() fails behind an OAuth2 proxy), decodes
+ * them with image-js into pixel matrices, and loads a stack through a small
+ * worker pool, reporting progress. Owns the stack-loading flag and progress.
+ */
+export class PlotlyImageLoader {
+    constructor(http) {
+        this.http = http;
+        /** Whether the whole stack is (to be) loaded; switching it off stops a stack load. */
+        this.stackLoading$ = new BehaviorSubject(false);
+        /** Stack load progress, 0–100 (0 when idle). */
+        this.stackLoadingProgress$ = new BehaviorSubject(0);
+        this.utils = new PlotUtilities();
+    }
+    /** Fetch one image via HttpClient and decode it. */
+    async loadImage(url, signal) {
+        const buffer = await firstValueFromAbortable(this.http.get(url, { responseType: 'arraybuffer' }), signal);
+        return Image.load(Buffer.from(buffer));
+    }
+    /**
+     * Load slice `zIndex` — or, for a shown stack, every slice (in parallel,
+     * keeping slice order). `onProbe` runs once the displayed slice has decoded;
+     * the stack load stops early when `stillWanted()` turns false (another file),
+     * stack loading is switched off, or `signal` aborts (it then rejects with an
+     * `AbortError`). A stopped load keeps the contiguous run of slices from the start.
+     */
+    async load(imageInfo, zIndex, signal, onProbe, stillWanted) {
+        const urls = imageInfo.urls;
+        const isGrayscale = imageInfo.isGrayscale;
+        const chUrls = channelPlaneUrls(imageInfo);
+        const planesOf = (z) => this.loadChannelPlanes(chUrls?.[z] ?? chUrls?.[0] ?? [], signal);
+        const image = await this.loadImage(zIndex ? urls[zIndex] : urls[0], signal);
+        const ratios = [imageInfo.trueImageSize[0] / image.width, imageInfo.trueImageSize[1] / image.height];
+        const sizes = [image.width, image.height];
+        onProbe();
+        if (!(imageInfo.isStack && imageInfo.showStack)) {
+            return {
+                data: [this.toMatrix(image, !!isGrayscale)],
+                ratios,
+                sizes,
+                filename: imageInfo.fileName,
+                ...(chUrls ? { channelPlanes: [await planesOf(zIndex || 0)] } : {}),
+            };
+        }
+        const wanted = () => stillWanted() && this.stackLoading$.value && !signal?.aborted;
+        const images = new Array(urls.length);
+        const planes = new Array(urls.length);
+        let next = 0;
+        let loaded = 0;
+        this.stackLoadingProgress$.next(0);
+        // One URL per slice, fetched by a small pool of workers; each slice keeps its index.
+        const worker = async () => {
+            while (next < urls.length && wanted()) {
+                const i = next++;
+                images[i] = this.toMatrix(await this.loadImage(urls[i], signal), !!isGrayscale);
+                if (chUrls)
+                    planes[i] = await planesOf(i);
+                this.stackLoadingProgress$.next(Math.round((++loaded * 100) / urls.length));
+            }
+        };
+        const poolSize = Math.min(PLOTLY_STACK_FETCH_CONCURRENCY, urls.length);
+        try {
+            await Promise.all(Array.from({ length: poolSize }, () => worker()));
+        }
+        catch (err) {
+            this.stackLoadingProgress$.next(0);
+            throw err;
+        }
+        throwIfAborted(signal);
+        const firstGap = images.findIndex((m) => m === undefined);
+        if (firstGap >= 0)
+            images.length = firstGap;
+        planes.length = images.length;
+        this.stackLoadingProgress$.next(0);
+        return {
+            data: images,
+            ratios,
+            sizes,
+            filename: imageInfo.fileName,
+            ...(chUrls ? { channelPlanes: planes } : {}),
+        };
+    }
+    /** A slice's channel planes (`channelUrls[z]`), fetched in parallel and decoded to one byte per
+     *  pixel (a 16-bit plane to its high byte, as a canvas decodes it for OSD). */
+    loadChannelPlanes(urls, signal) {
+        return Promise.all(urls.map(async (url) => {
+            const grey = (await this.loadImage(url, signal)).grey();
+            const data = grey.data;
+            return grey.bitDepth === 16 ? Uint8Array.from(data, (v) => v >> 8) : Uint8Array.from(data);
+        }));
+    }
+    /** Grayscale: the scalar matrix. Colour: `[r, g, b]` cells in 0..255, the only range an
+     *  `image` trace draws — a 16-bit image keeps each sample's high byte, as the browser decodes
+     *  it for OSD and napari-js (its full values saturated every cell). */
+    toMatrix(img, isGrayscale) {
+        if (isGrayscale)
+            return this.utils.arrayToMatrix(Array.from(img.grey().data), img.width);
+        const pixels = img.getPixelsArray();
+        const cells = img.bitDepth === 16 ? pixels.map((px) => px.map((v) => v >> 8)) : pixels;
+        return this.utils.arrayToMatrix(cells, img.width);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-image-loader.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-image-loader.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject } from 'rxjs';\nimport { Image } from 'image-js';\nimport { Buffer } from 'buffer';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { PlotUtilities } from '../../plot.utilities';\nimport { firstValueFromAbortable, throwIfAborted } from '../tile-server/transport';\nimport { channelPlaneUrls } from './plotly-image-recolor';\n\n/** Parallel slice fetches when loading a stack (cf. napari's volume fetch pool). */\nconst PLOTLY_STACK_FETCH_CONCURRENCY = 4;\n\n/** What Plotly's `load()` hands to `plot()`: per-slice pixel matrices. */\nexport interface PlotlyLoaded {\n  /** One row-major matrix per slice: grayscale numbers or `[r, g, b]` cells. */\n  data: any[];\n  /** [xRatio, yRatio]: image units per decoded pixel. */\n  ratios: number[];\n  /** [width, height] of a decoded slice. */\n  sizes: number[];\n  filename: string | undefined;\n  /** A serverless multichannel stack's raw channel planes (one byte per pixel), per loaded\n   *  slice (aligned with `data`) and channel — what its `image` trace is composited from. */\n  channelPlanes?: Uint8Array[][];\n}\n\n/**\n * Plotly's image source: fetches slices through HttpClient (so the auth\n * interceptors apply — a raw fetch() fails behind an OAuth2 proxy), decodes\n * them with image-js into pixel matrices, and loads a stack through a small\n * worker pool, reporting progress. Owns the stack-loading flag and progress.\n */\nexport class PlotlyImageLoader {\n  /** Whether the whole stack is (to be) loaded; switching it off stops a stack load. */\n  readonly stackLoading$ = new BehaviorSubject<boolean>(false);\n  /** Stack load progress, 0–100 (0 when idle). */\n  readonly stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  private readonly utils = new PlotUtilities();\n\n  constructor(private readonly http: HttpClient) {}\n\n  /** Fetch one image via HttpClient and decode it. */\n  async loadImage(url: string, signal?: AbortSignal): Promise<Image> {\n    const buffer = await firstValueFromAbortable(this.http.get(url, { responseType: 'arraybuffer' }), signal);\n    return Image.load(Buffer.from(buffer));\n  }\n\n  /**\n   * Load slice `zIndex` — or, for a shown stack, every slice (in parallel,\n   * keeping slice order). `onProbe` runs once the displayed slice has decoded;\n   * the stack load stops early when `stillWanted()` turns false (another file),\n   * stack loading is switched off, or `signal` aborts (it then rejects with an\n   * `AbortError`). A stopped load keeps the contiguous run of slices from the start.\n   */\n  async load(\n    imageInfo: IImageInfo,\n    zIndex: number,\n    signal: AbortSignal | undefined,\n    onProbe: () => void,\n    stillWanted: () => boolean,\n  ): Promise<PlotlyLoaded> {\n    const urls = imageInfo.urls;\n    const isGrayscale = imageInfo.isGrayscale;\n    const chUrls = channelPlaneUrls(imageInfo);\n    const planesOf = (z: number) => this.loadChannelPlanes(chUrls?.[z] ?? chUrls?.[0] ?? [], signal);\n    const image = await this.loadImage(zIndex ? urls[zIndex] : urls[0], signal);\n    const ratios = [imageInfo.trueImageSize[0] / image.width, imageInfo.trueImageSize[1] / image.height];\n    const sizes = [image.width, image.height];\n    onProbe();\n    if (!(imageInfo.isStack && imageInfo.showStack)) {\n      return {\n        data: [this.toMatrix(image, !!isGrayscale)],\n        ratios,\n        sizes,\n        filename: imageInfo.fileName,\n        ...(chUrls ? { channelPlanes: [await planesOf(zIndex || 0)] } : {}),\n      };\n    }\n    const wanted = () => stillWanted() && this.stackLoading$.value && !signal?.aborted;\n    const images: any[] = new Array(urls.length);\n    const planes: Uint8Array[][] = new Array(urls.length);\n    let next = 0;\n    let loaded = 0;\n    this.stackLoadingProgress$.next(0);\n    // One URL per slice, fetched by a small pool of workers; each slice keeps its index.\n    const worker = async () => {\n      while (next < urls.length && wanted()) {\n        const i = next++;\n        images[i] = this.toMatrix(await this.loadImage(urls[i], signal), !!isGrayscale);\n        if (chUrls) planes[i] = await planesOf(i);\n        this.stackLoadingProgress$.next(Math.round((++loaded * 100) / urls.length));\n      }\n    };\n    const poolSize = Math.min(PLOTLY_STACK_FETCH_CONCURRENCY, urls.length);\n    try {\n      await Promise.all(Array.from({ length: poolSize }, () => worker()));\n    } catch (err) {\n      this.stackLoadingProgress$.next(0);\n      throw err;\n    }\n    throwIfAborted(signal);\n    const firstGap = images.findIndex((m) => m === undefined);\n    if (firstGap >= 0) images.length = firstGap;\n    planes.length = images.length;\n    this.stackLoadingProgress$.next(0);\n    return {\n      data: images,\n      ratios,\n      sizes,\n      filename: imageInfo.fileName,\n      ...(chUrls ? { channelPlanes: planes } : {}),\n    };\n  }\n\n  /** A slice's channel planes (`channelUrls[z]`), fetched in parallel and decoded to one byte per\n   *  pixel (a 16-bit plane to its high byte, as a canvas decodes it for OSD). */\n  private loadChannelPlanes(urls: string[], signal?: AbortSignal): Promise<Uint8Array[]> {\n    return Promise.all(\n      urls.map(async (url) => {\n        const grey = (await this.loadImage(url, signal)).grey();\n        const data = grey.data as ArrayLike<number>;\n        return grey.bitDepth === 16 ? Uint8Array.from(data, (v) => v >> 8) : Uint8Array.from(data);\n      }),\n    );\n  }\n\n  /** Grayscale: the scalar matrix. Colour: `[r, g, b]` cells in 0..255, the only range an\n   *  `image` trace draws — a 16-bit image keeps each sample's high byte, as the browser decodes\n   *  it for OSD and napari-js (its full values saturated every cell). */\n  private toMatrix(img: any, isGrayscale: boolean): any[] {\n    if (isGrayscale) return this.utils.arrayToMatrix(Array.from(img.grey().data), img.width);\n    const pixels: number[][] = img.getPixelsArray();\n    const cells = img.bitDepth === 16 ? pixels.map((px) => px.map((v) => v >> 8)) : pixels;\n    return this.utils.arrayToMatrix(cells, img.width);\n  }\n}\n"]}

package/esm2022/lib/implementations/plotly/plotly-image-recolor.mjs

@@ -0,0 +1,178 @@
+import { DisplayPipeline, rgbNeedsRecolor } from '../osd/display-pipeline';
+/** A serverless multichannel stack's per-channel plane URLs (`channelUrls[z][c]`), or null: the
+ *  criterion OSD's simple source and napari-js's stitch path use. */
+export function channelPlaneUrls(info) {
+    const urls = info?.channelUrls;
+    return urls?.length && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1 ? urls : null;
+}
+/**
+ * Which channel display the `image` trace of `info` gets: `multichannel` when the slices'
+ * channel planes were loaded, `rgb` for an RGB image (its channels are R, G and B — the store's
+ * channel model for `rgbChannels ≥ 3`), else none. A tiled multichannel image is plotted from
+ * the server's flat composite preview, with no per-channel pixels to recolour: none.
+ */
+export function recolorKind(info, hasPlanes) {
+    if (!info || info.isGrayscale)
+        return null;
+    if (hasPlanes)
+        return 'multichannel';
+    return (info.imageMeta?.[0]?.rgbChannels ?? 0) >= 3 ? 'rgb' : null;
+}
+/** A Plotly `image` frame (rows of `[r, g, b(, a)]` cells) as opaque RGBA8 pixels. */
+export function matrixToRgba(frame, width, height) {
+    const out = new Uint8ClampedArray(width * height * 4);
+    for (let y = 0, o = 0; y < height; y++) {
+        const row = frame[y];
+        for (let x = 0; x < width; x++, o += 4) {
+            const cell = row?.[x];
+            if (!cell)
+                continue;
+            out[o] = cell[0];
+            out[o + 1] = cell[1];
+            out[o + 2] = cell[2];
+            out[o + 3] = 255;
+        }
+    }
+    return out;
+}
+/** The browser's PNG encoder, off the main thread where it can be (`convertToBlob`/`toBlob`
+ *  encode asynchronously), read back as a data URI. */
+export const encodePng = async (rgba, width, height) => {
+    const pixels = new ImageData(rgba, width, height);
+    let blob;
+    if (typeof OffscreenCanvas !== 'undefined') {
+        const canvas = new OffscreenCanvas(width, height);
+        canvas.getContext('2d').putImageData(pixels, 0, 0);
+        blob = await canvas.convertToBlob({ type: 'image/png' });
+    }
+    else {
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        canvas.getContext('2d').putImageData(pixels, 0, 0);
+        blob = await new Promise((resolve) => canvas.toBlob(resolve, 'image/png'));
+    }
+    if (!blob)
+        throw new Error('[plotly] image encode failed');
+    const image = blob;
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error);
+        reader.readAsDataURL(image);
+    });
+};
+/**
+ * The channel display of Plotly's colour `image` trace (#46 browser testing): what OSD's
+ * {@link DisplayPipeline} does to its tiles, run on the CPU over the frames Plotly plots, so one
+ * channel state draws the same picture on both (window → invert → gamma → tint, additive merge).
+ *  - multichannel (a serverless stack's `channelUrls`): the slice's raw channel planes merged by
+ *    `compositeChannels`;
+ *  - RGB: the raw frame's R, G and B through their channels (`applyToRgba`) — the raw frame as it
+ *    is while the channel states leave it so ({@link rgbNeedsRecolor}).
+ *
+ * Always from the RAW pixels the plot was built from, never from a recoloured frame, so repeated
+ * edits never compound. The raw frames stay what the pixel tools, the profiles and the histogram
+ * read; only the trace's picture changes.
+ *
+ * The trace draws a PNG `source`, not a `z` matrix: Plotly paints a `z` image one `fillRect` per
+ * pixel (~0.7 s for a 1-megapixel slice, on every edit), while a `source` is drawn by the browser
+ * and encoded off the main thread. A stack recolours the slice on screen, and each other slice
+ * when it is shown ({@link frame} reports a stale one).
+ */
+export class PlotlyImageRecolor {
+    constructor(host, encode = encodePng) {
+        this.host = host;
+        this.encode = encode;
+        this.kind = null;
+        this.frames = [];
+        this.planes = [];
+        /** Per frame: the display key of the latest picture asked for it. */
+        this.shown = [];
+        /** Bumped by every plot/clear: a picture encoded for an older plot is dropped. */
+        this.generation = 0;
+        this.pipeline = new DisplayPipeline({
+            isGrayscale: () => false,
+            colorLut: () => null,
+            channelStates: () => this.host.channelStates(),
+            invertBg: () => this.host.invert(),
+        });
+    }
+    /** Whether the traces on screen follow the channel states. */
+    get active() {
+        return this.kind !== null;
+    }
+    /**
+     * Start following the channel states for the `image` traces about to be plotted from `frames`
+     * (raw, one per slice) and, for `multichannel`, each slice's raw channel `planes`. Resolves to
+     * each slice's `source` in the current display; null for `kind` null (the traces draw `z`), or
+     * when a newer plot superseded this one.
+     */
+    async plot(kind, frames, planes = []) {
+        this.generation++;
+        this.kind = kind;
+        this.frames = kind ? frames : [];
+        this.planes = kind ? planes : [];
+        this.shown = [];
+        if (!kind)
+            return null;
+        const sources = await Promise.all(frames.map((_f, i) => this.frame(i)));
+        return sources.every((s) => s !== null) ? sources : null;
+    }
+    /** Stop following (the plot was replaced by a non-image one, or purged). */
+    clear() {
+        this.generation++;
+        this.kind = null;
+        this.frames = [];
+        this.planes = [];
+        this.shown = [];
+    }
+    /** Slice `index`'s `source` in the current channel display, or null when the picture asked for
+     *  last already shows it, or a newer picture or plot superseded this one. */
+    async frame(index) {
+        if (!this.kind || !this.frames[index]?.length)
+            return null;
+        const key = JSON.stringify([this.host.channelStates(), this.host.invert()]);
+        if (this.shown[index] === key)
+            return null;
+        this.shown[index] = key;
+        const generation = this.generation;
+        const px = this.pixels(index);
+        const source = await this.encode(px.rgba, px.width, px.height);
+        return generation === this.generation && this.shown[index] === key ? source : null;
+    }
+    /** Slice `index`'s displayed pixels (`getDisplayedPixelData` of a trace drawn from its `source`),
+     *  as `[r, g, b]` like a `z` trace's; null when no trace follows the channel states. */
+    displayedPixels(index) {
+        const px = this.pixels(index);
+        if (!px)
+            return null;
+        const data = new Uint8ClampedArray(px.width * px.height * 3);
+        for (let i = 0, o = 0; o < data.length; i += 4, o += 3) {
+            data[o] = px.rgba[i];
+            data[o + 1] = px.rgba[i + 1];
+            data[o + 2] = px.rgba[i + 2];
+        }
+        return { width: px.width, height: px.height, channels: 3, data };
+    }
+    /** Slice `index` in the current channel display, as RGBA8, from its raw pixels. */
+    pixels(index) {
+        const raw = this.frames[index];
+        if (!this.kind || !raw?.length)
+            return null;
+        const height = raw.length;
+        const width = raw[0]?.length ?? 0;
+        const states = this.host.channelStates();
+        const invert = this.host.invert();
+        const planes = this.planes[index];
+        // A slice whose planes do not fit its frame (none were loaded) shows the frame as it is.
+        if (this.kind === 'multichannel' && planes?.length && planes.every((p) => p.length === width * height)) {
+            return { rgba: this.pipeline.compositeChannels(planes, states, 1), width, height };
+        }
+        const rgba = matrixToRgba(raw, width, height);
+        if (this.kind === 'rgb' && rgbNeedsRecolor(states, invert))
+            this.pipeline.applyToRgba(rgba);
+        return { rgba, width, height };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-image-recolor.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-image-recolor.ts"],"names":[],"mappings":"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","sourcesContent":["import { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { PixelData } from '../../contracts/visualizer.contract';\nimport { DisplayPipeline, rgbNeedsRecolor } from '../osd/display-pipeline';\n\n/** How the Plotly `image` trace of an image follows the Channels & Histogram dialog. */\nexport type RecolorKind = 'rgb' | 'multichannel';\n\n/** RGBA8 pixels → an `image` trace's `source` (a `data:image/…;base64,` URI). */\nexport type ImageEncoder = (rgba: Uint8ClampedArray, width: number, height: number) => Promise<string>;\n\n/** A serverless multichannel stack's per-channel plane URLs (`channelUrls[z][c]`), or null: the\n *  criterion OSD's simple source and napari-js's stitch path use. */\nexport function channelPlaneUrls(info: IImageInfo | undefined): string[][] | null {\n  const urls = info?.channelUrls;\n  return urls?.length && (info?.imageMeta?.[0]?.channelCount ?? 1) > 1 ? urls : null;\n}\n\n/**\n * Which channel display the `image` trace of `info` gets: `multichannel` when the slices'\n * channel planes were loaded, `rgb` for an RGB image (its channels are R, G and B — the store's\n * channel model for `rgbChannels ≥ 3`), else none. A tiled multichannel image is plotted from\n * the server's flat composite preview, with no per-channel pixels to recolour: none.\n */\nexport function recolorKind(info: IImageInfo | undefined, hasPlanes: boolean): RecolorKind | null {\n  if (!info || info.isGrayscale) return null;\n  if (hasPlanes) return 'multichannel';\n  return (info.imageMeta?.[0]?.rgbChannels ?? 0) >= 3 ? 'rgb' : null;\n}\n\n/** A Plotly `image` frame (rows of `[r, g, b(, a)]` cells) as opaque RGBA8 pixels. */\nexport function matrixToRgba(frame: number[][][], width: number, height: number): Uint8ClampedArray {\n  const out = new Uint8ClampedArray(width * height * 4);\n  for (let y = 0, o = 0; y < height; y++) {\n    const row = frame[y];\n    for (let x = 0; x < width; x++, o += 4) {\n      const cell = row?.[x];\n      if (!cell) continue;\n      out[o] = cell[0];\n      out[o + 1] = cell[1];\n      out[o + 2] = cell[2];\n      out[o + 3] = 255;\n    }\n  }\n  return out;\n}\n\n/** The browser's PNG encoder, off the main thread where it can be (`convertToBlob`/`toBlob`\n *  encode asynchronously), read back as a data URI. */\nexport const encodePng: ImageEncoder = async (rgba, width, height) => {\n  const pixels = new ImageData(rgba, width, height);\n  let blob: Blob | null;\n  if (typeof OffscreenCanvas !== 'undefined') {\n    const canvas = new OffscreenCanvas(width, height);\n    canvas.getContext('2d')!.putImageData(pixels, 0, 0);\n    blob = await canvas.convertToBlob({ type: 'image/png' });\n  } else {\n    const canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n    canvas.getContext('2d')!.putImageData(pixels, 0, 0);\n    blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));\n  }\n  if (!blob) throw new Error('[plotly] image encode failed');\n  const image = blob;\n  return new Promise<string>((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = () => reject(reader.error);\n    reader.readAsDataURL(image);\n  });\n};\n\n/**\n * The channel display of Plotly's colour `image` trace (#46 browser testing): what OSD's\n * {@link DisplayPipeline} does to its tiles, run on the CPU over the frames Plotly plots, so one\n * channel state draws the same picture on both (window → invert → gamma → tint, additive merge).\n *  - multichannel (a serverless stack's `channelUrls`): the slice's raw channel planes merged by\n *    `compositeChannels`;\n *  - RGB: the raw frame's R, G and B through their channels (`applyToRgba`) — the raw frame as it\n *    is while the channel states leave it so ({@link rgbNeedsRecolor}).\n *\n * Always from the RAW pixels the plot was built from, never from a recoloured frame, so repeated\n * edits never compound. The raw frames stay what the pixel tools, the profiles and the histogram\n * read; only the trace's picture changes.\n *\n * The trace draws a PNG `source`, not a `z` matrix: Plotly paints a `z` image one `fillRect` per\n * pixel (~0.7 s for a 1-megapixel slice, on every edit), while a `source` is drawn by the browser\n * and encoded off the main thread. A stack recolours the slice on screen, and each other slice\n * when it is shown ({@link frame} reports a stale one).\n */\nexport class PlotlyImageRecolor {\n  private kind: RecolorKind | null = null;\n  private frames: number[][][][] = [];\n  private planes: Array<Uint8Array[] | undefined> = [];\n  /** Per frame: the display key of the latest picture asked for it. */\n  private shown: string[] = [];\n  /** Bumped by every plot/clear: a picture encoded for an older plot is dropped. */\n  private generation = 0;\n  private readonly pipeline: DisplayPipeline;\n\n  constructor(\n    private readonly host: { channelStates(): IChannelState[]; invert(): boolean },\n    private readonly encode: ImageEncoder = encodePng,\n  ) {\n    this.pipeline = new DisplayPipeline({\n      isGrayscale: () => false,\n      colorLut: () => null,\n      channelStates: () => this.host.channelStates(),\n      invertBg: () => this.host.invert(),\n    });\n  }\n\n  /** Whether the traces on screen follow the channel states. */\n  get active(): boolean {\n    return this.kind !== null;\n  }\n\n  /**\n   * Start following the channel states for the `image` traces about to be plotted from `frames`\n   * (raw, one per slice) and, for `multichannel`, each slice's raw channel `planes`. Resolves to\n   * each slice's `source` in the current display; null for `kind` null (the traces draw `z`), or\n   * when a newer plot superseded this one.\n   */\n  async plot(\n    kind: RecolorKind | null,\n    frames: number[][][][],\n    planes: Array<Uint8Array[] | undefined> = [],\n  ): Promise<string[] | null> {\n    this.generation++;\n    this.kind = kind;\n    this.frames = kind ? frames : [];\n    this.planes = kind ? planes : [];\n    this.shown = [];\n    if (!kind) return null;\n    const sources = await Promise.all(frames.map((_f, i) => this.frame(i)));\n    return sources.every((s): s is string => s !== null) ? sources : null;\n  }\n\n  /** Stop following (the plot was replaced by a non-image one, or purged). */\n  clear(): void {\n    this.generation++;\n    this.kind = null;\n    this.frames = [];\n    this.planes = [];\n    this.shown = [];\n  }\n\n  /** Slice `index`'s `source` in the current channel display, or null when the picture asked for\n   *  last already shows it, or a newer picture or plot superseded this one. */\n  async frame(index: number): Promise<string | null> {\n    if (!this.kind || !this.frames[index]?.length) return null;\n    const key = JSON.stringify([this.host.channelStates(), this.host.invert()]);\n    if (this.shown[index] === key) return null;\n    this.shown[index] = key;\n    const generation = this.generation;\n    const px = this.pixels(index)!;\n    const source = await this.encode(px.rgba, px.width, px.height);\n    return generation === this.generation && this.shown[index] === key ? source : null;\n  }\n\n  /** Slice `index`'s displayed pixels (`getDisplayedPixelData` of a trace drawn from its `source`),\n   *  as `[r, g, b]` like a `z` trace's; null when no trace follows the channel states. */\n  displayedPixels(index: number): PixelData | null {\n    const px = this.pixels(index);\n    if (!px) return null;\n    const data = new Uint8ClampedArray(px.width * px.height * 3);\n    for (let i = 0, o = 0; o < data.length; i += 4, o += 3) {\n      data[o] = px.rgba[i];\n      data[o + 1] = px.rgba[i + 1];\n      data[o + 2] = px.rgba[i + 2];\n    }\n    return { width: px.width, height: px.height, channels: 3, data };\n  }\n\n  /** Slice `index` in the current channel display, as RGBA8, from its raw pixels. */\n  private pixels(index: number): { rgba: Uint8ClampedArray; width: number; height: number } | null {\n    const raw = this.frames[index];\n    if (!this.kind || !raw?.length) return null;\n    const height = raw.length;\n    const width = raw[0]?.length ?? 0;\n    const states = this.host.channelStates();\n    const invert = this.host.invert();\n    const planes = this.planes[index];\n    // A slice whose planes do not fit its frame (none were loaded) shows the frame as it is.\n    if (this.kind === 'multichannel' && planes?.length && planes.every((p) => p.length === width * height)) {\n      return { rgba: this.pipeline.compositeChannels(planes, states, 1), width, height };\n    }\n    const rgba = matrixToRgba(raw, width, height);\n    if (this.kind === 'rgb' && rgbNeedsRecolor(states, invert)) this.pipeline.applyToRgba(rgba);\n    return { rgba, width, height };\n  }\n}\n"]}

package/esm2022/lib/implementations/plotly/plotly-intensity-inset.mjs

@@ -0,0 +1,33 @@
+import * as Plotly from 'plotly.js-dist-min';
+/**
+ * Render the floating intensity-profile inset chart into `divId` — one line
+ * trace per profile line, each drawn in its line's colour. The x axis is in
+ * microns when the sampler tagged the profiles so (the image carries a pixel
+ * size), otherwise in pixels. A no-op when the element is missing.
+ */
+export function renderIntensityInset(divId, profiles) {
+    const el = document.getElementById(divId);
+    if (!el)
+        return;
+    const traces = (profiles ?? []).map((p, i) => ({
+        x: p.positions,
+        y: p.values,
+        type: 'scatter',
+        mode: 'lines',
+        line: { color: p.color ?? '#FFD400', width: 2 },
+        name: `Line ${i + 1}`,
+        hoverinfo: 'x+y',
+    }));
+    const unit = (profiles ?? []).find((p) => p.unit)?.unit ?? 'px';
+    const xTitle = unit === 'µm' ? 'Position (µm)' : 'Position (px)';
+    void Plotly.react(el, traces, {
+        margin: { t: 6, r: 8, b: 38, l: 40 },
+        xaxis: { title: xTitle, zeroline: false, color: '#ddd' },
+        yaxis: { title: 'Intensity', zeroline: false, color: '#ddd' },
+        showlegend: false,
+        paper_bgcolor: 'rgba(25,25,25,0.9)',
+        plot_bgcolor: 'rgba(25,25,25,0.9)',
+        font: { color: '#eee', size: 10 },
+    }, { displayModeBar: false, responsive: true });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/plotly/plotly-isosurface-controls.mjs

@@ -0,0 +1,83 @@
+import { bt601Luminance } from '../../contracts/intensity';
+/** The toolbar iso slider's domain (isoValueMax). */
+const SLIDER_MAX = 255;
+/** Min/max intensity over every voxel of the frames (RGB → luminance), or null
+ *  for empty or flat input. */
+export function measureIntensityRange(frames, isGrayscale) {
+    let min = Infinity, max = -Infinity;
+    for (const frame of frames || []) {
+        for (const row of frame || []) {
+            for (const cell of row || []) {
+                const v = isGrayscale ? cell : bt601Luminance(cell[0], cell[1], cell[2]);
+                if (!Number.isFinite(v))
+                    continue;
+                if (v < min)
+                    min = v;
+                if (v > max)
+                    max = v;
+            }
+        }
+    }
+    return Number.isFinite(min) && Number.isFinite(max) && max > min ? [min, max] : null;
+}
+/**
+ * The ISOSURFACE intensity band. The slider is a fixed 0–255, but a stack often
+ * occupies only a narrow sub-range (e.g. an EDOF volume at ~2–50 with structure
+ * near 6–10), so the band is mapped onto the volume's measured range: every
+ * intensity is easy to reach and the band always lands inside the data — a
+ * small inset keeps the extreme surfaces off the exact data edges, which are
+ * degenerate and draw nothing.
+ */
+export class PlotlyIsosurfaceControls {
+    /**
+     * @param isLive whether an isosurface is on screen now
+     * @param restyle restyles the live isosurface's `isomin`/`isomax`
+     */
+    constructor(isLive, restyle) {
+        this.isLive = isLive;
+        this.restyle = restyle;
+        /** The band as 0–255 slider positions. Defaults to the full range so the
+         *  first render shows the whole structure. */
+        this.isoMin = 0;
+        this.isoMax = SLIDER_MAX;
+        /** The measured [min, max] of the volume on screen; null until measured. */
+        this.dataRange = null;
+    }
+    /** Measure the volume about to be rendered, so the band maps onto its range. */
+    measure(frames, isGrayscale) {
+        this.dataRange = measureIntensityRange(frames, isGrayscale);
+    }
+    /** The current band in data units, for the next render. */
+    band() {
+        return this.mapBand(this.isoMin, this.isoMax);
+    }
+    /** Update the band; a live isosurface is restyled in place (no volume rebuild). */
+    setIsoRange(isoMin, isoMax) {
+        this.isoMin = isoMin;
+        this.isoMax = isoMax;
+        if (this.isLive()) {
+            const [lo, hi] = this.mapBand(isoMin, isoMax);
+            this.restyle({ isomin: [lo], isomax: [hi] });
+        }
+    }
+    /** Slider band → data units, through the measured range (as-is before one). */
+    mapBand(isoMin, isoMax) {
+        let lo = Math.min(isoMin, isoMax);
+        let hi = Math.max(isoMin, isoMax);
+        if (this.dataRange) {
+            const [vMin, vMax] = this.dataRange;
+            const span = vMax - vMin;
+            const pad = 0.03 * span;
+            const usable = span - 2 * pad;
+            lo = vMin + pad + (lo / SLIDER_MAX) * usable;
+            hi = vMin + pad + (hi / SLIDER_MAX) * usable;
+            if (lo > hi) {
+                const t = lo;
+                lo = hi;
+                hi = t;
+            }
+        }
+        return [lo, hi];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-isosurface-controls.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-isosurface-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import { IIsosurfaceControls } from '../../contracts/visualizer.contract';\nimport { bt601Luminance } from '../../contracts/intensity';\n\n/** The toolbar iso slider's domain (isoValueMax). */\nconst SLIDER_MAX = 255;\n\n/** Min/max intensity over every voxel of the frames (RGB → luminance), or null\n *  for empty or flat input. */\nexport function measureIntensityRange(frames: any[], isGrayscale: boolean): [number, number] | null {\n  let min = Infinity,\n    max = -Infinity;\n  for (const frame of frames || []) {\n    for (const row of frame || []) {\n      for (const cell of row || []) {\n        const v = isGrayscale ? cell : bt601Luminance(cell[0], cell[1], cell[2]);\n        if (!Number.isFinite(v)) continue;\n        if (v < min) min = v;\n        if (v > max) max = v;\n      }\n    }\n  }\n  return Number.isFinite(min) && Number.isFinite(max) && max > min ? [min, max] : null;\n}\n\n/**\n * The ISOSURFACE intensity band. The slider is a fixed 0–255, but a stack often\n * occupies only a narrow sub-range (e.g. an EDOF volume at ~2–50 with structure\n * near 6–10), so the band is mapped onto the volume's measured range: every\n * intensity is easy to reach and the band always lands inside the data — a\n * small inset keeps the extreme surfaces off the exact data edges, which are\n * degenerate and draw nothing.\n */\nexport class PlotlyIsosurfaceControls implements IIsosurfaceControls {\n  /** The band as 0–255 slider positions. Defaults to the full range so the\n   *  first render shows the whole structure. */\n  private isoMin = 0;\n  private isoMax = SLIDER_MAX;\n  /** The measured [min, max] of the volume on screen; null until measured. */\n  private dataRange: [number, number] | null = null;\n\n  /**\n   * @param isLive whether an isosurface is on screen now\n   * @param restyle restyles the live isosurface's `isomin`/`isomax`\n   */\n  constructor(\n    private readonly isLive: () => boolean,\n    private readonly restyle: (update: { isomin: number[]; isomax: number[] }) => void,\n  ) {}\n\n  /** Measure the volume about to be rendered, so the band maps onto its range. */\n  measure(frames: any[], isGrayscale: boolean): void {\n    this.dataRange = measureIntensityRange(frames, isGrayscale);\n  }\n\n  /** The current band in data units, for the next render. */\n  band(): [number, number] {\n    return this.mapBand(this.isoMin, this.isoMax);\n  }\n\n  /** Update the band; a live isosurface is restyled in place (no volume rebuild). */\n  setIsoRange(isoMin: number, isoMax: number): void {\n    this.isoMin = isoMin;\n    this.isoMax = isoMax;\n    if (this.isLive()) {\n      const [lo, hi] = this.mapBand(isoMin, isoMax);\n      this.restyle({ isomin: [lo], isomax: [hi] });\n    }\n  }\n\n  /** Slider band → data units, through the measured range (as-is before one). */\n  private mapBand(isoMin: number, isoMax: number): [number, number] {\n    let lo = Math.min(isoMin, isoMax);\n    let hi = Math.max(isoMin, isoMax);\n    if (this.dataRange) {\n      const [vMin, vMax] = this.dataRange;\n      const span = vMax - vMin;\n      const pad = 0.03 * span;\n      const usable = span - 2 * pad;\n      lo = vMin + pad + (lo / SLIDER_MAX) * usable;\n      hi = vMin + pad + (hi / SLIDER_MAX) * usable;\n      if (lo > hi) {\n        const t = lo;\n        lo = hi;\n        hi = t;\n      }\n    }\n    return [lo, hi];\n  }\n}\n"]}