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

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

@@ -29,4 +29,4 @@ export class OsdCoordinateTransform {
         return Math.abs(b.x - a.x);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-coords.mjs

@@ -11,16 +11,15 @@ import { OSD } from './osd-lib';
  * step on the viewport (which is unambiguous). Falls back to the viewport methods
  * when the world is empty.
  */
-const osd = OSD;
 /** Reference tiled image for image<->viewport conversions (any slice works since
  *  they share geometry). */
 function refItem(viewer) {
-    return viewer?.world?.getItemCount?.() > 0 ? viewer.world.getItemAt(0) : null;
+    return (viewer.world?.getItemCount() ?? 0) > 0 ? (viewer.world.getItemAt(0) ?? null) : null;
 }
 /** Viewer-element pixel -> image (data) coordinates. */
 export function elementToImage(viewer, x, y) {
     const vp = viewer.viewport;
-    const pt = new osd.Point(x, y);
+    const pt = new OSD.Point(x, y);
     const item = refItem(viewer);
     const img = item
         ? item.viewportToImageCoordinates(vp.viewerElementToViewportCoordinates(pt))
@@ -30,7 +29,7 @@ export function elementToImage(viewer, x, y) {
 /** Image (data) coordinates -> viewer-element pixel point. */
 export function imageToElement(viewer, x, y) {
     const vp = viewer.viewport;
-    const pt = new osd.Point(x, y);
+    const pt = new OSD.Point(x, y);
     const item = refItem(viewer);
     const p = item
         ? vp.viewportToViewerElementCoordinates(item.imageToViewportCoordinates(pt))
@@ -39,7 +38,7 @@ export function imageToElement(viewer, x, y) {
 }
 /** Image-space rectangle -> viewport rectangle (for fitBounds). */
 export function imageRectToViewport(viewer, x, y, w, h) {
-    const rect = new osd.Rect(x, y, w, h);
+    const rect = new OSD.Rect(x, y, w, h);
     const item = refItem(viewer);
     return item ? item.imageToViewportRectangle(rect) : viewer.viewport.imageToViewportRectangle(rect);
 }
@@ -50,4 +49,4 @@ export function viewportRectToImage(viewer, vpRect) {
     const item = refItem(viewer);
     return item ? item.viewportToImageRectangle(vpRect) : viewer.viewport.viewportToImageRectangle(vpRect);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-export.mjs

@@ -0,0 +1,122 @@
+import { firstValueFrom } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+import { buildTileUrl, fetchTileBitmap } from './tile-client';
+/** Largest level an export stitches (~32 MP) — bounds memory for whole-slide images. */
+const EXPORT_PIXEL_CAP = 32_000_000;
+/**
+ * Render the current slice as a publication-ready PNG composited with the
+ * active display settings (window / gamma / colormap or per-channel pseudo-
+ * colours / invert). Picks the largest pyramid level under a pixel cap (the
+ * coarser overview for huge whole-slides), fetches that level's tile grid,
+ * stitches it into one canvas and runs the shared display pipeline. A
+ * per-channel (multichannel) image is exported the way it is drawn: each
+ * visible channel's tiles are stitched and merged additively with its tint.
+ * Null when there is nothing to export.
+ */
+export async function renderCompositePng(input) {
+    const { descriptor: desc, http, api, infoB64, z, display } = input;
+    // Per-channel tiles exist only at the real Bio-Formats levels.
+    const levels = input.multiChannel ? desc.levels.slice(0, input.realLevels) : desc.levels;
+    if (!infoB64 || !levels.length)
+        return null;
+    let res = levels.length - 1; // coarsest fallback
+    for (let i = 0; i < levels.length; i++) {
+        if (levels[i].width * levels[i].height <= EXPORT_PIXEL_CAP) {
+            res = i;
+            break;
+        }
+    }
+    const lw = levels[res].width;
+    const lh = levels[res].height;
+    const t = desc.tileSize;
+    const cols = Math.max(1, Math.ceil(lw / t));
+    const rows = Math.max(1, Math.ceil(lh / t));
+    const canvas = document.createElement('canvas');
+    canvas.width = lw;
+    canvas.height = lh;
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    if (!ctx)
+        return null;
+    /** Stitch the level's tile grid (server composite, or one channel) into the canvas. */
+    const stitch = async (channel) => {
+        ctx.clearRect(0, 0, lw, lh);
+        const jobs = [];
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                const url = buildTileUrl(api, infoB64, { res, col, row, z, tileSize: t, channel });
+                jobs.push((async () => {
+                    try {
+                        const bmp = await fetchTileBitmap(http, url, 30000);
+                        ctx.drawImage(bmp, col * t, row * t);
+                        bmp.close?.();
+                    }
+                    catch (err) {
+                        // Skip a failed tile — the exported composite has a gap there.
+                        console.warn('[viz:export] composite tile fetch failed, skipping', url, err);
+                    }
+                })());
+            }
+        }
+        await Promise.all(jobs);
+    };
+    try {
+        if (input.multiChannel) {
+            const states = input.channelStates;
+            const nCh = Math.max(1, states.length || (desc.channels ?? 1));
+            let out = null;
+            let imageData = null;
+            for (let c = 0; c < nCh; c++) {
+                if (states[c]?.visible === false)
+                    continue;
+                await stitch(c);
+                imageData = ctx.getImageData(0, 0, lw, lh);
+                out ??= new Uint8ClampedArray(imageData.data.length);
+                display.addChannel(out, imageData.data, states[c]);
+            }
+            if (imageData && out) {
+                for (let i = 3; i < out.length; i += 4)
+                    out[i] = 255; // opaque
+                imageData.data.set(out);
+                ctx.putImageData(imageData, 0, 0);
+            }
+            else {
+                ctx.clearRect(0, 0, lw, lh); // every channel hidden
+            }
+        }
+        else {
+            await stitch();
+            const imageData = ctx.getImageData(0, 0, lw, lh);
+            if (display.applyToRgba(imageData.data))
+                ctx.putImageData(imageData, 0, 0);
+        }
+    }
+    catch (err) {
+        // Keep the un-recolored composite if readback fails — but say why.
+        console.warn('[viz:export] composite recolor readback failed — exporting raw tiles', err);
+    }
+    return new Promise((resolve) => canvas.toBlob(resolve, 'image/png'));
+}
+/**
+ * Fetch the data-preserving multi-band TIFF from `GET /export/tiff` (the server
+ * reads the raw native-bit-depth planes — the client never sees them). Null
+ * while the file is still caching (202) or on failure, which is logged.
+ */
+export async function fetchTiffExport(http, url) {
+    try {
+        const resp = await firstValueFrom(http.get(url, { observe: 'response', responseType: 'blob' }).pipe(timeout(600000)));
+        if (resp.status === 202) {
+            console.warn('[OSD] 16-bit export: file still caching — try again shortly.');
+            return null;
+        }
+        return resp.body;
+    }
+    catch (err) {
+        console.warn('[OSD] 16-bit TIFF export failed', err);
+        return null;
+    }
+}
+/** `name.tif` → `name` (the export file stem; `image` when there is no name). */
+export function fileStem(fileName) {
+    return (fileName || 'image').replace(/\.[^.]+$/, '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-export.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-export.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\n\nimport { buildTileUrl, fetchTileBitmap } from './tile-client';\nimport { DisplayPipeline } from './display-pipeline';\nimport { TileDescriptor } from '../tile-server';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\n\n/** Largest level an export stitches (~32 MP) — bounds memory for whole-slide images. */\nconst EXPORT_PIXEL_CAP = 32_000_000;\n\n/** What {@link renderCompositePng} draws. */\nexport interface CompositeExportInput {\n  http: HttpClient;\n  api: string;\n  descriptor: TileDescriptor;\n  infoB64: string;\n  z: number;\n  /** Drawn per channel (one TiledImage per channel), from the real levels only. */\n  multiChannel: boolean;\n  realLevels: number;\n  channelStates: IChannelState[];\n  display: DisplayPipeline;\n}\n\n/**\n * Render the current slice as a publication-ready PNG composited with the\n * active display settings (window / gamma / colormap or per-channel pseudo-\n * colours / invert). Picks the largest pyramid level under a pixel cap (the\n * coarser overview for huge whole-slides), fetches that level's tile grid,\n * stitches it into one canvas and runs the shared display pipeline. A\n * per-channel (multichannel) image is exported the way it is drawn: each\n * visible channel's tiles are stitched and merged additively with its tint.\n * Null when there is nothing to export.\n */\nexport async function renderCompositePng(input: CompositeExportInput): Promise<Blob | null> {\n  const { descriptor: desc, http, api, infoB64, z, display } = input;\n  // Per-channel tiles exist only at the real Bio-Formats levels.\n  const levels = input.multiChannel ? desc.levels.slice(0, input.realLevels) : desc.levels;\n  if (!infoB64 || !levels.length) return null;\n  let res = levels.length - 1; // coarsest fallback\n  for (let i = 0; i < levels.length; i++) {\n    if (levels[i].width * levels[i].height <= EXPORT_PIXEL_CAP) {\n      res = i;\n      break;\n    }\n  }\n  const lw = levels[res].width;\n  const lh = levels[res].height;\n  const t = desc.tileSize;\n  const cols = Math.max(1, Math.ceil(lw / t));\n  const rows = Math.max(1, Math.ceil(lh / t));\n  const canvas = document.createElement('canvas');\n  canvas.width = lw;\n  canvas.height = lh;\n  const ctx = canvas.getContext('2d', { willReadFrequently: true });\n  if (!ctx) return null;\n  /** Stitch the level's tile grid (server composite, or one channel) into the canvas. */\n  const stitch = async (channel?: number): Promise<void> => {\n    ctx.clearRect(0, 0, lw, lh);\n    const jobs: Promise<void>[] = [];\n    for (let row = 0; row < rows; row++) {\n      for (let col = 0; col < cols; col++) {\n        const url = buildTileUrl(api, infoB64, { res, col, row, z, tileSize: t, channel });\n        jobs.push(\n          (async () => {\n            try {\n              const bmp = await fetchTileBitmap(http, url, 30000);\n              ctx.drawImage(bmp, col * t, row * t);\n              bmp.close?.();\n            } catch (err) {\n              // Skip a failed tile — the exported composite has a gap there.\n              console.warn('[viz:export] composite tile fetch failed, skipping', url, err);\n            }\n          })(),\n        );\n      }\n    }\n    await Promise.all(jobs);\n  };\n  try {\n    if (input.multiChannel) {\n      const states = input.channelStates;\n      const nCh = Math.max(1, states.length || (desc.channels ?? 1));\n      let out: Uint8ClampedArray | null = null;\n      let imageData: ImageData | null = null;\n      for (let c = 0; c < nCh; c++) {\n        if (states[c]?.visible === false) continue;\n        await stitch(c);\n        imageData = ctx.getImageData(0, 0, lw, lh);\n        out ??= new Uint8ClampedArray(imageData.data.length);\n        display.addChannel(out, imageData.data, states[c]);\n      }\n      if (imageData && out) {\n        for (let i = 3; i < out.length; i += 4) out[i] = 255; // opaque\n        imageData.data.set(out);\n        ctx.putImageData(imageData, 0, 0);\n      } else {\n        ctx.clearRect(0, 0, lw, lh); // every channel hidden\n      }\n    } else {\n      await stitch();\n      const imageData = ctx.getImageData(0, 0, lw, lh);\n      if (display.applyToRgba(imageData.data)) ctx.putImageData(imageData, 0, 0);\n    }\n  } catch (err) {\n    // Keep the un-recolored composite if readback fails — but say why.\n    console.warn('[viz:export] composite recolor readback failed — exporting raw tiles', err);\n  }\n  return new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, 'image/png'));\n}\n\n/**\n * Fetch the data-preserving multi-band TIFF from `GET /export/tiff` (the server\n * reads the raw native-bit-depth planes — the client never sees them). Null\n * while the file is still caching (202) or on failure, which is logged.\n */\nexport async function fetchTiffExport(http: HttpClient, url: string): Promise<Blob | null> {\n  try {\n    const resp = await firstValueFrom(\n      http.get(url, { observe: 'response', responseType: 'blob' }).pipe(timeout(600000)), // large exports stream slowly; generous deadline\n    );\n    if (resp.status === 202) {\n      console.warn('[OSD] 16-bit export: file still caching — try again shortly.');\n      return null;\n    }\n    return resp.body;\n  } catch (err) {\n    console.warn('[OSD] 16-bit TIFF export failed', err);\n    return null;\n  }\n}\n\n/** `name.tif` → `name` (the export file stem; `image` when there is no name). */\nexport function fileStem(fileName: string | undefined): string {\n  return (fileName || 'image').replace(/\\.[^.]+$/, '');\n}\n"]}

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

@@ -17,4 +17,18 @@ import * as OpenSeadragon from 'openseadragon';
  * it real named exports and plain member access works.)
  */
 export const OSD = OpenSeadragon.default ?? OpenSeadragon;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3NkLWxpYi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvaW1wbGVtZW50YXRpb25zL29zZC9vc2QtbGliLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxhQUFhLE1BQU0sZUFBZSxDQUFDO0FBRS9DOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUNiLGFBQXFCLENBQUMsT0FBTyxJQUFJLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIE9wZW5TZWFkcmFnb24gZnJvbSAnb3BlbnNlYWRyYWdvbic7XG5cbi8qKlxuICogVGhlIHJlYWwgT3BlblNlYWRyYWdvbiBvYmplY3QsIG5vcm1hbGl6ZWQgZm9yIHRoZSBwYWNrYWdlZCAoRkVTTSkgYnVpbGQuXG4gKlxuICogT3BlblNlYWRyYWdvbiBzaGlwcyBhcyBwbGFpbiBDb21tb25KUyAoYG1vZHVsZS5leHBvcnRzID0gT3BlblNlYWRyYWdvbmAsIG5vXG4gKiBgX19lc01vZHVsZWAgZmxhZykuIEJ1bmRsZWQgaW50byB0aGlzIGxpYnJhcnkncyBGRVNNIGFuZCByZS1idW5kbGVkIGJ5IGFcbiAqIGNvbnN1bWluZyBhcHAsIGBpbXBvcnQgKiBhcyBPcGVuU2VhZHJhZ29uYCByZXNvbHZlcyB0byBhIHN5bnRoZXNpemVkIEVTXG4gKiBuYW1lc3BhY2Ugd2hvc2Ugb25seSByZWxpYWJsZSBzbG90IGlzIGAuZGVmYXVsdGAgKHRoZSByZWFsIGBtb2R1bGUuZXhwb3J0c2ApLlxuICogVGhlIGZhY3RvcnkgaXRzZWxmIGFuZCBldmVyeSBzdGF0aWMgbWVtYmVyIChWaWV3ZXIsIFBvaW50LCBSZWN0LCBUaWxlU291cmNlLCDigKYpXG4gKiBsaXZlIG9uIHRoYXQgb2JqZWN0LCBOT1Qgb24gdGhlIG5hbWVzcGFjZSDigJQgc28gYE9wZW5TZWFkcmFnb24oLi4uKWAgb3JcbiAqIGBuZXcgT3BlblNlYWRyYWdvbi5Qb2ludCgpYCBhZ2FpbnN0IHRoZSBuYW1lc3BhY2UgZmFpbCBvbmNlIHBhY2thZ2VkXG4gKiAoXCJpcyBub3QgYSBmdW5jdGlvblwiIC8gXCJub3QgYSBjb25zdHJ1Y3RvclwiKS4gTm9ybWFsaXplIE9OQ0UgaGVyZSBhbmQgaW1wb3J0XG4gKiB7IE9TRCB9IHdoZXJldmVyIGEgcnVudGltZSBWQUxVRSBpcyBuZWVkZWQ7IGltcG9ydCB0aGUgYG9wZW5zZWFkcmFnb25gIG5hbWVzcGFjZVxuICogZGlyZWN0bHkgb25seSBmb3IgaXRzIFRZUEVTIChlLmcuIGBPcGVuU2VhZHJhZ29uLlZpZXdlcmApLlxuICpcbiAqIChwbG90bHkuanMtZGlzdC1taW4gbmVlZHMgbm8gZXF1aXZhbGVudDogaXQgc2V0cyBgX19lc01vZHVsZWAsIHNvIHdlYnBhY2sgZ2l2ZXNcbiAqIGl0IHJlYWwgbmFtZWQgZXhwb3J0cyBhbmQgcGxhaW4gbWVtYmVyIGFjY2VzcyB3b3Jrcy4pXG4gKi9cbmV4cG9ydCBjb25zdCBPU0Q6IHR5cGVvZiBPcGVuU2VhZHJhZ29uID1cbiAgKE9wZW5TZWFkcmFnb24gYXMgYW55KS5kZWZhdWx0ID8/IE9wZW5TZWFkcmFnb247XG4iXX0=
+/**
+ * Run an operation on an OSD tiled image, navigator or viewer that may already
+ * have been torn down (a slice evicted mid-load, the viewer destroyed during an
+ * animation or a timed refit). A throw there is expected and harmless, so it is
+ * only logged at debug level instead of being swallowed silently.
+ */
+export function quiet(fn) {
+    try {
+        fn();
+    }
+    catch (err) {
+        console.debug('[OSD] ignored error from a torn-down viewer item', err);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/osd/osd-navigator-chrome.mjs

@@ -0,0 +1,205 @@
+import { quiet } from './osd-lib';
+/**
+ * The viewer chrome and its browser workarounds: the overview navigator
+ * (visibility, sizing, corner pinning), image smoothing, the initial
+ * fit-to-view as the host layout settles, and the docked-toolbar repaint nudge.
+ *
+ * `navigatorVisible` and `smoothingEnabled` are read when a viewer is created
+ * (see buildViewerOptions) and applied live to a mounted one.
+ */
+export class OsdNavigatorChrome {
+    static { this.TOOLBAR_NUDGE_INTERVAL_MS = 100; }
+    constructor(host) {
+        this.host = host;
+        /** Whether the overview navigator (minimap) is shown. A consumer that doesn't
+         *  want it (e.g. a small embedded preview) sets it off before the first render. */
+        this.navigatorVisible = true;
+        /** Image smoothing (bilinear). `false` → nearest-neighbour, so zoomed-in pixels
+         *  render as crisp blocks (pixel inspection). Defaults to `false` so the image
+         *  opens showing raw pixels. */
+        this.smoothingEnabled = false;
+        /** The host's docked toolbar (see nudgeToolbarRepaint): undefined until looked
+         *  up for the current mount, null when there is none. */
+        this.toolbarDock = undefined;
+        this.lastToolbarNudge = 0;
+    }
+    /** A new image is being mounted: the toolbar is looked up again for it. */
+    onMount() {
+        this.toolbarDock = undefined;
+    }
+    /**
+     * Wire the chrome onto a freshly opened viewer: the toolbar nudges, the
+     * fit-to-view retries as the layout settles, and the navigator re-sizing.
+     */
+    attach(viewer, plotDiv) {
+        // Chrome compositor bug: after an OSD zoom the docked toolbar (a sibling of
+        // #plot in the <visualizer> host) is left laid-out-but-unpainted and
+        // vanishes — confirmed via DevTools (DOM intact, region simply not painted).
+        // CSS (z-index / isolation / contain) and DOM-reparenting don't fix it; a
+        // repaint reliably does. Nudge it during the animation (throttled — each
+        // nudge forces a layout) and on settle. The synchronous display toggle
+        // re-rasters with no visible gone-frame and no layout shift.
+        viewer.addHandler('animation', () => this.nudgeToolbarRepaint(true));
+        viewer.addHandler('animation-finish', () => this.nudgeToolbarRepaint());
+        // Force fit-to-view as the split/flex layout settles. A tall
+        // non-pyramidal image can otherwise open zoomed-in (image width filling
+        // the viewer), making OSD demand slow full-res res=0 tiles for the
+        // centre instead of the fast coarse overview → white canvas. goHome
+        // fits the whole image so OSD selects the coarse synthetic level. Retry
+        // across a few frames because the container may not have its final size
+        // on the first frame after 'open'.
+        const refit = () => quiet(() => {
+            this.host.viewer()?.viewport.goHome(true);
+            // The navigator was sized in the Viewer constructor — BEFORE the
+            // layout settled — so its element can carry a stale (even
+            // wrong-aspect) size that floats the visible minimap above the
+            // corner. Re-size it from the settled container.
+            this.resizeNavigator();
+        });
+        requestAnimationFrame(refit);
+        setTimeout(refit, 150);
+        setTimeout(refit, 400);
+        // The timed retries above miss the case where the container is STILL
+        // zero-size at 400ms — which happens when the render starts while the
+        // file viewer is mid-switch from the folder view to the diagram (e.g.
+        // "Load as Stack" from a folder, with no image open first). Because
+        // preserveViewport suppresses OSD's own open-time fit, the image would
+        // then be left un-fitted at the top-left ("a tile"). A one-shot
+        // ResizeObserver fits the instant the container first has a real size,
+        // regardless of when the render began (jit-ui#106).
+        this.fitWhenContainerSized(document.getElementById(plotDiv), refit);
+        // Keep the navigator sized to the container as the panel resizes.
+        viewer.addHandler('resize', () => this.resizeNavigator());
+    }
+    /** Show/hide the overview navigator. Stored for the next viewer creation, and
+     *  applied live when a viewer is already mounted (hides/reveals its element —
+     *  the navigator instance itself only exists when created with showNavigator). */
+    setNavigatorVisible(visible) {
+        this.navigatorVisible = visible;
+        const navEl = this.host.viewer()?.navigator?.element;
+        if (navEl)
+            navEl.style.display = visible ? '' : 'none';
+    }
+    /** Toggle bilinear smoothing vs nearest-neighbour (crisp pixels). Stored for the
+     *  next viewer creation, and applied live (with a redraw) to a mounted viewer. */
+    setImageSmoothingEnabled(enabled) {
+        this.smoothingEnabled = enabled;
+        const viewer = this.host.viewer();
+        const drawer = viewer?.drawer;
+        if (drawer?.setImageSmoothingEnabled) {
+            drawer.setImageSmoothingEnabled(enabled);
+            viewer?.forceRedraw();
+        }
+    }
+    /**
+     * Fit-to-home once `el` first has a non-zero size. If it's already sized we
+     * rely on the timed refits the caller scheduled; otherwise a one-shot
+     * ResizeObserver runs `refit` the moment the container is laid out (then
+     * disconnects), so the initial fit doesn't depend on the render's start time
+     * relative to the diagram container's layout. No-op without a container or
+     * ResizeObserver (the timed refits remain the fallback). One-shot + only
+     * attached on a fresh mount, so slice-scrub re-opens keep the user's zoom.
+     */
+    fitWhenContainerSized(el, refit) {
+        if (!el || typeof ResizeObserver === 'undefined')
+            return;
+        if (el.clientWidth > 0 && el.clientHeight > 0)
+            return; // already sized — timed refits suffice
+        const ro = new ResizeObserver(() => {
+            if (el.clientWidth > 0 && el.clientHeight > 0) {
+                ro.disconnect();
+                refit();
+            }
+        });
+        ro.observe(el);
+        // Safety net: stop observing even if it never gains a size.
+        setTimeout(() => ro.disconnect(), 5000);
+    }
+    /** Size the navigator from the CURRENT container (navigatorSizeRatio of the
+     *  viewer element) and keep it pinned to the corner. OSD computes the size
+     *  once in the Viewer constructor — before the host flex layout settles —
+     *  and never corrects it, leaving a stale-size element whose visible minimap
+     *  floats above the bottom-right corner. */
+    resizeNavigator() {
+        const v = this.host.viewer();
+        const nav = v?.navigator;
+        const el = v?.element;
+        if (!nav?.element || !el?.clientWidth || !el?.clientHeight)
+            return;
+        const w = Math.round(el.clientWidth * 0.16);
+        const h = Math.round(el.clientHeight * 0.16);
+        if (nav.element.style.width !== `${w}px` || nav.element.style.height !== `${h}px`) {
+            quiet(() => {
+                nav.setWidth(w);
+                nav.setHeight(h);
+            });
+        }
+        // Normalize OSD's control-corner stack so the minimap sits flush in the
+        // corner, inset 12px to line up with the scale bar:
+        //  - the inline-block wrapper carries line-box struts and can retain stale
+        //    sizing → make it a tight block;
+        //  - anything else OSD left in the corner would stack below the navigator
+        //    and float it up → hide it;
+        //  - inset the corner itself (bottom/right 12px), keeping the element in
+        //    normal flow.
+        const wrapper = nav.element.parentElement;
+        const corner = wrapper?.parentElement;
+        if (wrapper && corner) {
+            wrapper.style.display = 'block';
+            wrapper.style.lineHeight = '0';
+            wrapper.style.fontSize = '0';
+            // The wrapper keeps the navigator's stale pre-settle height as an
+            // explicit size (the nav was 0.16x the UNSETTLED container at creation),
+            // leaving an empty band under the resized minimap — measured live:
+            // navH=87 inside wrapH=167. Force it to hug its content.
+            wrapper.style.height = 'auto';
+            wrapper.style.width = 'auto';
+            for (const child of Array.from(corner.children)) {
+                if (child !== wrapper)
+                    child.style.display = 'none';
+            }
+            for (const child of Array.from(wrapper.children)) {
+                if (child !== nav.element)
+                    child.style.display = 'none';
+            }
+            corner.style.bottom = '12px';
+            corner.style.right = '12px';
+        }
+        Object.assign(nav.element.style, {
+            position: 'relative',
+            top: '',
+            left: '',
+            bottom: '',
+            right: '',
+            margin: '0',
+        });
+    }
+    /** Force the docked toolbar to repaint after an OSD zoom. Chrome leaves it
+     *  laid-out-but-unpainted (the canvas's compositing churn strands the toolbar's
+     *  raster). A synchronous display toggle re-rasters it with no visible gone-frame
+     *  and no layout shift. Located via the DOM since the service doesn't own the
+     *  toolbar; a no-op when there's no toolbar (e.g. embedded without one). The
+     *  element is looked up once per mount. `throttled` (animation frames) nudges
+     *  at most every {@link TOOLBAR_NUDGE_INTERVAL_MS}: each nudge forces a layout. */
+    nudgeToolbarRepaint(throttled = false) {
+        if (throttled) {
+            const now = performance.now();
+            if (now - this.lastToolbarNudge < OsdNavigatorChrome.TOOLBAR_NUDGE_INTERVAL_MS)
+                return;
+            this.lastToolbarNudge = now;
+        }
+        if (this.toolbarDock === undefined || (this.toolbarDock && !this.toolbarDock.isConnected)) {
+            const plotDiv = this.host.plotDiv();
+            const plotEl = plotDiv ? document.getElementById(plotDiv) : null;
+            this.toolbarDock = plotEl?.closest('visualization')?.querySelector('.toolbar-dock') ?? null;
+        }
+        const dock = this.toolbarDock;
+        if (!dock)
+            return;
+        const prev = dock.style.display;
+        dock.style.display = 'none';
+        void dock.offsetHeight; // reflow so the toggle re-rasters on the next paint
+        dock.style.display = prev;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"osd-navigator-chrome.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/osd-navigator-chrome.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as OpenSeadragon from 'openseadragon';\n\nimport { quiet } from './osd-lib';\n\n/** The service state the chrome reads — live, so it follows a viewer rebuild. */\nexport interface OsdChromeHost {\n  viewer(): OpenSeadragon.Viewer | null;\n  /** The DOM id OSD is mounted in. */\n  plotDiv(): string;\n}\n\n/**\n * The viewer chrome and its browser workarounds: the overview navigator\n * (visibility, sizing, corner pinning), image smoothing, the initial\n * fit-to-view as the host layout settles, and the docked-toolbar repaint nudge.\n *\n * `navigatorVisible` and `smoothingEnabled` are read when a viewer is created\n * (see buildViewerOptions) and applied live to a mounted one.\n */\nexport class OsdNavigatorChrome {\n  /** Whether the overview navigator (minimap) is shown. A consumer that doesn't\n   *  want it (e.g. a small embedded preview) sets it off before the first render. */\n  navigatorVisible = true;\n  /** Image smoothing (bilinear). `false` → nearest-neighbour, so zoomed-in pixels\n   *  render as crisp blocks (pixel inspection). Defaults to `false` so the image\n   *  opens showing raw pixels. */\n  smoothingEnabled = false;\n  /** The host's docked toolbar (see nudgeToolbarRepaint): undefined until looked\n   *  up for the current mount, null when there is none. */\n  private toolbarDock: HTMLElement | null | undefined = undefined;\n  private lastToolbarNudge = 0;\n  static readonly TOOLBAR_NUDGE_INTERVAL_MS = 100;\n\n  constructor(private readonly host: OsdChromeHost) {}\n\n  /** A new image is being mounted: the toolbar is looked up again for it. */\n  onMount(): void {\n    this.toolbarDock = undefined;\n  }\n\n  /**\n   * Wire the chrome onto a freshly opened viewer: the toolbar nudges, the\n   * fit-to-view retries as the layout settles, and the navigator re-sizing.\n   */\n  attach(viewer: OpenSeadragon.Viewer, plotDiv: string): void {\n    // Chrome compositor bug: after an OSD zoom the docked toolbar (a sibling of\n    // #plot in the <visualizer> host) is left laid-out-but-unpainted and\n    // vanishes — confirmed via DevTools (DOM intact, region simply not painted).\n    // CSS (z-index / isolation / contain) and DOM-reparenting don't fix it; a\n    // repaint reliably does. Nudge it during the animation (throttled — each\n    // nudge forces a layout) and on settle. The synchronous display toggle\n    // re-rasters with no visible gone-frame and no layout shift.\n    viewer.addHandler('animation', () => this.nudgeToolbarRepaint(true));\n    viewer.addHandler('animation-finish', () => this.nudgeToolbarRepaint());\n    // Force fit-to-view as the split/flex layout settles. A tall\n    // non-pyramidal image can otherwise open zoomed-in (image width filling\n    // the viewer), making OSD demand slow full-res res=0 tiles for the\n    // centre instead of the fast coarse overview → white canvas. goHome\n    // fits the whole image so OSD selects the coarse synthetic level. Retry\n    // across a few frames because the container may not have its final size\n    // on the first frame after 'open'.\n    const refit = () =>\n      quiet(() => {\n        this.host.viewer()?.viewport.goHome(true);\n        // The navigator was sized in the Viewer constructor — BEFORE the\n        // layout settled — so its element can carry a stale (even\n        // wrong-aspect) size that floats the visible minimap above the\n        // corner. Re-size it from the settled container.\n        this.resizeNavigator();\n      });\n    requestAnimationFrame(refit);\n    setTimeout(refit, 150);\n    setTimeout(refit, 400);\n    // The timed retries above miss the case where the container is STILL\n    // zero-size at 400ms — which happens when the render starts while the\n    // file viewer is mid-switch from the folder view to the diagram (e.g.\n    // \"Load as Stack\" from a folder, with no image open first). Because\n    // preserveViewport suppresses OSD's own open-time fit, the image would\n    // then be left un-fitted at the top-left (\"a tile\"). A one-shot\n    // ResizeObserver fits the instant the container first has a real size,\n    // regardless of when the render began (jit-ui#106).\n    this.fitWhenContainerSized(document.getElementById(plotDiv), refit);\n    // Keep the navigator sized to the container as the panel resizes.\n    viewer.addHandler('resize', () => this.resizeNavigator());\n  }\n\n  /** Show/hide the overview navigator. Stored for the next viewer creation, and\n   *  applied live when a viewer is already mounted (hides/reveals its element —\n   *  the navigator instance itself only exists when created with showNavigator). */\n  setNavigatorVisible(visible: boolean): void {\n    this.navigatorVisible = visible;\n    const navEl: HTMLElement | undefined = this.host.viewer()?.navigator?.element;\n    if (navEl) navEl.style.display = visible ? '' : 'none';\n  }\n\n  /** Toggle bilinear smoothing vs nearest-neighbour (crisp pixels). Stored for the\n   *  next viewer creation, and applied live (with a redraw) to a mounted viewer. */\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.smoothingEnabled = enabled;\n    const viewer = this.host.viewer();\n    const drawer = viewer?.drawer;\n    if (drawer?.setImageSmoothingEnabled) {\n      drawer.setImageSmoothingEnabled(enabled);\n      viewer?.forceRedraw();\n    }\n  }\n\n  /**\n   * Fit-to-home once `el` first has a non-zero size. If it's already sized we\n   * rely on the timed refits the caller scheduled; otherwise a one-shot\n   * ResizeObserver runs `refit` the moment the container is laid out (then\n   * disconnects), so the initial fit doesn't depend on the render's start time\n   * relative to the diagram container's layout. No-op without a container or\n   * ResizeObserver (the timed refits remain the fallback). One-shot + only\n   * attached on a fresh mount, so slice-scrub re-opens keep the user's zoom.\n   */\n  fitWhenContainerSized(el: HTMLElement | null, refit: () => void): void {\n    if (!el || typeof ResizeObserver === 'undefined') return;\n    if (el.clientWidth > 0 && el.clientHeight > 0) return; // already sized — timed refits suffice\n    const ro = new ResizeObserver(() => {\n      if (el.clientWidth > 0 && el.clientHeight > 0) {\n        ro.disconnect();\n        refit();\n      }\n    });\n    ro.observe(el);\n    // Safety net: stop observing even if it never gains a size.\n    setTimeout(() => ro.disconnect(), 5000);\n  }\n\n  /** Size the navigator from the CURRENT container (navigatorSizeRatio of the\n   *  viewer element) and keep it pinned to the corner. OSD computes the size\n   *  once in the Viewer constructor — before the host flex layout settles —\n   *  and never corrects it, leaving a stale-size element whose visible minimap\n   *  floats above the bottom-right corner. */\n  resizeNavigator(): void {\n    const v = this.host.viewer();\n    const nav = v?.navigator;\n    const el: HTMLElement | undefined = v?.element;\n    if (!nav?.element || !el?.clientWidth || !el?.clientHeight) return;\n    const w = Math.round(el.clientWidth * 0.16);\n    const h = Math.round(el.clientHeight * 0.16);\n    if (nav.element.style.width !== `${w}px` || nav.element.style.height !== `${h}px`) {\n      quiet(() => {\n        nav.setWidth(w);\n        nav.setHeight(h);\n      });\n    }\n    // Normalize OSD's control-corner stack so the minimap sits flush in the\n    // corner, inset 12px to line up with the scale bar:\n    //  - the inline-block wrapper carries line-box struts and can retain stale\n    //    sizing → make it a tight block;\n    //  - anything else OSD left in the corner would stack below the navigator\n    //    and float it up → hide it;\n    //  - inset the corner itself (bottom/right 12px), keeping the element in\n    //    normal flow.\n    const wrapper = nav.element.parentElement as HTMLElement | null;\n    const corner = wrapper?.parentElement as HTMLElement | null;\n    if (wrapper && corner) {\n      wrapper.style.display = 'block';\n      wrapper.style.lineHeight = '0';\n      wrapper.style.fontSize = '0';\n      // The wrapper keeps the navigator's stale pre-settle height as an\n      // explicit size (the nav was 0.16x the UNSETTLED container at creation),\n      // leaving an empty band under the resized minimap — measured live:\n      // navH=87 inside wrapH=167. Force it to hug its content.\n      wrapper.style.height = 'auto';\n      wrapper.style.width = 'auto';\n      for (const child of Array.from(corner.children) as HTMLElement[]) {\n        if (child !== wrapper) child.style.display = 'none';\n      }\n      for (const child of Array.from(wrapper.children) as HTMLElement[]) {\n        if (child !== nav.element) child.style.display = 'none';\n      }\n      corner.style.bottom = '12px';\n      corner.style.right = '12px';\n    }\n    Object.assign(nav.element.style, {\n      position: 'relative',\n      top: '',\n      left: '',\n      bottom: '',\n      right: '',\n      margin: '0',\n    });\n  }\n\n  /** Force the docked toolbar to repaint after an OSD zoom. Chrome leaves it\n   *  laid-out-but-unpainted (the canvas's compositing churn strands the toolbar's\n   *  raster). A synchronous display toggle re-rasters it with no visible gone-frame\n   *  and no layout shift. Located via the DOM since the service doesn't own the\n   *  toolbar; a no-op when there's no toolbar (e.g. embedded without one). The\n   *  element is looked up once per mount. `throttled` (animation frames) nudges\n   *  at most every {@link TOOLBAR_NUDGE_INTERVAL_MS}: each nudge forces a layout. */\n  nudgeToolbarRepaint(throttled = false): void {\n    if (throttled) {\n      const now = performance.now();\n      if (now - this.lastToolbarNudge < OsdNavigatorChrome.TOOLBAR_NUDGE_INTERVAL_MS) return;\n      this.lastToolbarNudge = now;\n    }\n    if (this.toolbarDock === undefined || (this.toolbarDock && !this.toolbarDock.isConnected)) {\n      const plotDiv = this.host.plotDiv();\n      const plotEl = plotDiv ? document.getElementById(plotDiv) : null;\n      this.toolbarDock = plotEl?.closest('visualization')?.querySelector<HTMLElement>('.toolbar-dock') ?? null;\n    }\n    const dock = this.toolbarDock;\n    if (!dock) return;\n    const prev = dock.style.display;\n    dock.style.display = 'none';\n    void dock.offsetHeight; // reflow so the toggle re-rasters on the next paint\n    dock.style.display = prev;\n  }\n}\n"]}

package/esm2022/lib/implementations/osd/osd-pixel-readback.mjs

@@ -0,0 +1,68 @@
+import { elementToImage } from './osd-coords';
+import { packedFrame } from '../../toolbar/tool-kit/frame-pixels';
+/** The 2D drawer's canvas (OSD is created with `drawer: 'canvas'`), if it has a size. */
+function drawerCanvas(viewer) {
+    const canvas = viewer?.drawer?.canvas;
+    return canvas && canvas.width && canvas.height ? canvas : null;
+}
+/**
+ * The currently displayed pixels — the rendered viewport (what the user sees,
+ * including the current zoom and any colormap recolor), as RGBA. Null until
+ * tiles are drawn.
+ */
+export function readDrawerPixels(viewer) {
+    const canvas = drawerCanvas(viewer);
+    const ctx = canvas?.getContext('2d', { willReadFrequently: true });
+    if (!canvas || !ctx)
+        return null;
+    const { width, height } = canvas;
+    const img = ctx.getImageData(0, 0, width, height);
+    return { width, height, channels: 4, data: img.data };
+}
+/**
+ * Read back the *currently rendered* OSD canvas as the pixel tools' frame.
+ * The frame covers only the visible viewport at screen resolution, so when
+ * the user is zoomed into a sub-region the wand samples that region's detail
+ * (rather than the whole image at preview resolution). `originX/originY` and
+ * `ratios` map image coords <-> readback-pixel coords for the wand's
+ * data/ratio/origin model. The RGBA readback is the frame as-is (packed,
+ * RT-17 / OSD-PLOTLY-12): no per-pixel arrays.
+ */
+export function readbackViewportFrame(viewer) {
+    const canvas = drawerCanvas(viewer);
+    if (!canvas || !viewer?.viewport)
+        return null;
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    if (!ctx)
+        return null;
+    const w = canvas.width; // device pixels
+    const h = canvas.height;
+    const data = ctx.getImageData(0, 0, w, h).data;
+    // Image-coord span the readback covers (CSS px in, image coords out). Route
+    // through world item 0 (osd-coords) so it stays accurate — and quiet — when
+    // the world holds multiple images (per-channel multichannel layers).
+    const elW = canvas.clientWidth || w;
+    const elH = canvas.clientHeight || h;
+    const tl = elementToImage(viewer, 0, 0);
+    const br = elementToImage(viewer, elW, elH);
+    const ratioX = (br.x - tl.x) / w; // image px per readback px
+    const ratioY = (br.y - tl.y) / h;
+    return {
+        frames: [packedFrame(data, w, h)],
+        width: w,
+        height: h,
+        ratios: [ratioX, ratioY],
+        isGrayscale: false, // canvas readback is always RGBA
+        originX: tl.x,
+        originY: tl.y,
+    };
+}
+/** Save the rendered view (the drawer canvas) as `<stem>.png`; a no-op before
+ *  anything is drawn. */
+export function saveDrawerSnapshot(viewer, save) {
+    drawerCanvas(viewer)?.toBlob((blob) => {
+        if (blob)
+            save(blob);
+    }, 'image/png');
+}
+//# sourceMappingURL=data:application/json;base64,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