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

package/esm2022/lib/implementations/osd/openseadragon-viewer-options.mjs

@@ -0,0 +1,128 @@
+import { OSD } from './osd-lib';
+import { OSD_ZOOM_PER_SCROLL } from './osd-zoom';
+/**
+ * Quiet OpenSeadragon's "[Viewport.*] is not accurate with multi-image" advisories.
+ * A multichannel image is composited from one TiledImage per channel — a legitimate
+ * multi-image world — and OSD logs that advisory (at error level) from its own
+ * navigator/overview rendering on every animation frame, flooding the console. Our
+ * own image<->viewport conversions already route through world item 0 (see
+ * osd-coords), so the remaining advisories are OSD-internal and only affect the
+ * minimap's box accuracy (cosmetic). This wraps OSD's logger in a Proxy that drops
+ * only that one message string and forwards every other log untouched. Idempotent.
+ */
+export function silenceOsdMultiImageAdvisory() {
+    const osd = OSD;
+    if (osd.__multiImageFilterInstalled)
+        return;
+    const base = osd.console && typeof osd.console.error === 'function'
+        ? osd.console
+        : typeof console !== 'undefined'
+            ? console
+            : null;
+    if (!base)
+        return;
+    const isAdvisory = (a) => typeof a === 'string' && a.indexOf('not accurate with multi-image') !== -1;
+    osd.console = new Proxy(base, {
+        get(target, prop) {
+            const orig = target[prop];
+            if ((prop === 'error' || prop === 'warn') && typeof orig === 'function') {
+                return (...args) => {
+                    if (isAdvisory(args[0]))
+                        return;
+                    orig.apply(target, args);
+                };
+            }
+            return typeof orig === 'function' ? orig.bind(target) : orig;
+        },
+    });
+    osd.__multiImageFilterInstalled = true;
+}
+/**
+ * The options object handed to the OpenSeadragon factory. Pure: every value
+ * that depends on the service comes in through `input`.
+ *
+ * These are OSD config keys, not library code: OSD silently falls back to its
+ * own default when one is misspelled or renamed upstream, so the values we rely
+ * on are pinned by `openseadragon-viewer-options.spec.ts`.
+ */
+export function buildViewerOptions(input) {
+    return {
+        id: input.id,
+        // Simple-mode z-scrub calls viewer.open() again per slice (see
+        // setZIndex) — without this it resets to the home zoom/pan on every
+        // slice change. Tiled mode never re-opens (it toggles pre-added
+        // TiledImages' opacity instead), so this is a no-op there.
+        preserveViewport: true,
+        // Use the 2D canvas drawer, not WebGL: creating/destroying a viewer on
+        // each engine toggle / image load churns WebGL contexts (browsers cap
+        // how many exist at once), which surfaces as "WebGL context was lost"
+        // and blank tiles. The canvas drawer has no such limit.
+        drawer: 'canvas',
+        showNavigationControl: false, // avoids needing the icon-image assets
+        // Overview thumbnail with the current-viewport rectangle, bottom-right.
+        showNavigator: input.navigatorVisible,
+        // Nearest-neighbour when off → crisp pixels on zoom-in (pixel inspection).
+        imageSmoothingEnabled: input.smoothing,
+        navigatorPosition: 'BOTTOM_RIGHT',
+        navigatorSizeRatio: 0.16,
+        navigatorAutoFade: false,
+        navigatorBackground: 'rgba(0,0,0,0.5)',
+        loadTilesWithAjax: true,
+        ajaxWithCredentials: true, // cookie auth (oauth2-proxy)
+        ajaxHeaders: input.authHeaders, // bearer auth (Auth0), when available
+        crossOriginPolicy: 'Anonymous',
+        // Gentler zoom: the default (1.2) feels fast and big jumps cross several
+        // pyramid levels at once, firing a burst of tile requests. Shared with the
+        // region overlay, which takes the wheel over while a tool is active.
+        zoomPerScroll: OSD_ZOOM_PER_SCROLL,
+        // Click-to-zoom toward the clicked point (OpenSeadragon's default demo
+        // behaviour). Only applies when no region tool is active — an active tool
+        // disables OSD mouse-nav so clicks draw/select instead of zooming.
+        gestureSettingsMouse: { clickToZoom: true, scrollToZoom: true },
+        // Zoom limits (jit-ui#94). Default minZoomImageRatio (0.9) stops you from
+        // zooming the image smaller than ~home; drop it so the image can be shrunk
+        // freely (effectively no minimum). Default maxZoomPixelRatio (1.1) caps
+        // zoom-in at ~1 screen px per image px; raise it so you can zoom in to
+        // inspect individual pixels (paired with imageSmoothingEnabled=false for
+        // crisp nearest-neighbour blocks).
+        minZoomImageRatio: 0.01,
+        maxZoomPixelRatio: 20,
+        // OSD's stock value, restored. DO NOT RAISE IT: the name reads like
+        // "minimum sharpness" but it is the opposite. From OSD's own
+        // TiledImage._getLevelsInterval:
+        //
+        //   highestLevel = floor( log2( currentZeroRatio / minPixelRatio ) )
+        //
+        // minPixelRatio is a floor on how small a tile pixel may shrink, and it
+        // DIVIDES into the ratio - so raising it lowers the chosen level, i.e.
+        // picks a COARSER image. OSD's own comment on the default says as much:
+        // "closer to 0 draws tiles meant for a higher zoom at this zoom".
+        //
+        // Measured on a flat 22304x24528 image (levels 697/1394/2788/5576/11152/
+        // 22304), predicted level matching actual in all nine trials:
+        //
+        //            zoom 2        zoom 8        ~1:1
+        //   1.0      1.34x up      1.34x up      1.86x up
+        //   0.5      0.67x (none)  0.67x (none)  0.93x -> full res
+        //   0.25     0.33x         0.33x         0.93x
+        //
+        // 0.5 is what gives "never upscaled below native, full resolution at 1:1".
+        // 0.25 is not better - it jumps two rungs finer and fetches ~4x the tiles
+        // for no visible gain, and tiles are not cached by the ingress.
+        minPixelRatio: 0.5,
+        // Wait for the view to settle before pulling new tiles (less churn).
+        immediateRender: false,
+        animationTime: 0.4,
+        // Release memory aggressively: cap the tile cache so tiles outside the
+        // current view (e.g. the coarser levels left behind after zooming in) are
+        // evicted instead of accumulating. Large whole-slide tiles — doubled when
+        // the colormap pipeline keeps a recolored copy — make an unbounded cache
+        // costly. Tunable; lower = less memory, more re-fetch on pan-back.
+        // Stacks keep many slices resident (the whole stack is background-loaded),
+        // so they get a much larger tile budget — otherwise switching slices evicts
+        // each other's tiles and scrubbing back re-fetches. Scaled to the resident
+        // slice count; single images keep the lean default.
+        maxImageCacheCount: input.sliceCount > 1 ? Math.min(2400, Math.max(600, input.maxSlices * 40)) : 150,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openseadragon-viewer-options.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/openseadragon-viewer-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { OSD } from './osd-lib';\nimport { OSD_ZOOM_PER_SCROLL } from './osd-zoom';\n\n/**\n * Quiet OpenSeadragon's \"[Viewport.*] is not accurate with multi-image\" advisories.\n * A multichannel image is composited from one TiledImage per channel — a legitimate\n * multi-image world — and OSD logs that advisory (at error level) from its own\n * navigator/overview rendering on every animation frame, flooding the console. Our\n * own image<->viewport conversions already route through world item 0 (see\n * osd-coords), so the remaining advisories are OSD-internal and only affect the\n * minimap's box accuracy (cosmetic). This wraps OSD's logger in a Proxy that drops\n * only that one message string and forwards every other log untouched. Idempotent.\n */\nexport function silenceOsdMultiImageAdvisory(): void {\n  const osd: any = OSD as any;\n  if (osd.__multiImageFilterInstalled) return;\n  const base: any =\n    osd.console && typeof osd.console.error === 'function'\n      ? osd.console\n      : typeof console !== 'undefined'\n        ? console\n        : null;\n  if (!base) return;\n  const isAdvisory = (a: unknown) => typeof a === 'string' && a.indexOf('not accurate with multi-image') !== -1;\n  osd.console = new Proxy(base, {\n    get(target: any, prop: string) {\n      const orig = target[prop];\n      if ((prop === 'error' || prop === 'warn') && typeof orig === 'function') {\n        return (...args: any[]) => {\n          if (isAdvisory(args[0])) return;\n          orig.apply(target, args);\n        };\n      }\n      return typeof orig === 'function' ? orig.bind(target) : orig;\n    },\n  });\n  osd.__multiImageFilterInstalled = true;\n}\n\n/** What {@link buildViewerOptions} needs to know about the viewer being mounted. */\nexport interface ViewerOptionsInput {\n  /** The DOM id OSD mounts into. */\n  id: string;\n  /** Show the overview navigator (minimap). */\n  navigatorVisible: boolean;\n  /** Bilinear smoothing; false gives crisp nearest-neighbour pixels. */\n  smoothing: boolean;\n  /** Bearer token for OSD's own tile fetches (its loader bypasses HttpClient). */\n  authHeaders: Record<string, string>;\n  /** Slices in the image (1 for a single image). */\n  sliceCount: number;\n  /** How many slices the slice cache keeps resident (see SliceCache.maxSlices). */\n  maxSlices: number;\n}\n\n/**\n * The options object handed to the OpenSeadragon factory. Pure: every value\n * that depends on the service comes in through `input`.\n *\n * These are OSD config keys, not library code: OSD silently falls back to its\n * own default when one is misspelled or renamed upstream, so the values we rely\n * on are pinned by `openseadragon-viewer-options.spec.ts`.\n */\nexport function buildViewerOptions(input: ViewerOptionsInput): Record<string, unknown> {\n  return {\n    id: input.id,\n    // Simple-mode z-scrub calls viewer.open() again per slice (see\n    // setZIndex) — without this it resets to the home zoom/pan on every\n    // slice change. Tiled mode never re-opens (it toggles pre-added\n    // TiledImages' opacity instead), so this is a no-op there.\n    preserveViewport: true,\n    // Use the 2D canvas drawer, not WebGL: creating/destroying a viewer on\n    // each engine toggle / image load churns WebGL contexts (browsers cap\n    // how many exist at once), which surfaces as \"WebGL context was lost\"\n    // and blank tiles. The canvas drawer has no such limit.\n    drawer: 'canvas',\n    showNavigationControl: false, // avoids needing the icon-image assets\n    // Overview thumbnail with the current-viewport rectangle, bottom-right.\n    showNavigator: input.navigatorVisible,\n    // Nearest-neighbour when off → crisp pixels on zoom-in (pixel inspection).\n    imageSmoothingEnabled: input.smoothing,\n    navigatorPosition: 'BOTTOM_RIGHT',\n    navigatorSizeRatio: 0.16,\n    navigatorAutoFade: false,\n    navigatorBackground: 'rgba(0,0,0,0.5)',\n    loadTilesWithAjax: true,\n    ajaxWithCredentials: true, // cookie auth (oauth2-proxy)\n    ajaxHeaders: input.authHeaders, // bearer auth (Auth0), when available\n    crossOriginPolicy: 'Anonymous',\n    // Gentler zoom: the default (1.2) feels fast and big jumps cross several\n    // pyramid levels at once, firing a burst of tile requests. Shared with the\n    // region overlay, which takes the wheel over while a tool is active.\n    zoomPerScroll: OSD_ZOOM_PER_SCROLL,\n    // Click-to-zoom toward the clicked point (OpenSeadragon's default demo\n    // behaviour). Only applies when no region tool is active — an active tool\n    // disables OSD mouse-nav so clicks draw/select instead of zooming.\n    gestureSettingsMouse: { clickToZoom: true, scrollToZoom: true },\n    // Zoom limits (jit-ui#94). Default minZoomImageRatio (0.9) stops you from\n    // zooming the image smaller than ~home; drop it so the image can be shrunk\n    // freely (effectively no minimum). Default maxZoomPixelRatio (1.1) caps\n    // zoom-in at ~1 screen px per image px; raise it so you can zoom in to\n    // inspect individual pixels (paired with imageSmoothingEnabled=false for\n    // crisp nearest-neighbour blocks).\n    minZoomImageRatio: 0.01,\n    maxZoomPixelRatio: 20,\n    // OSD's stock value, restored. DO NOT RAISE IT: the name reads like\n    // \"minimum sharpness\" but it is the opposite. From OSD's own\n    // TiledImage._getLevelsInterval:\n    //\n    //   highestLevel = floor( log2( currentZeroRatio / minPixelRatio ) )\n    //\n    // minPixelRatio is a floor on how small a tile pixel may shrink, and it\n    // DIVIDES into the ratio - so raising it lowers the chosen level, i.e.\n    // picks a COARSER image. OSD's own comment on the default says as much:\n    // \"closer to 0 draws tiles meant for a higher zoom at this zoom\".\n    //\n    // Measured on a flat 22304x24528 image (levels 697/1394/2788/5576/11152/\n    // 22304), predicted level matching actual in all nine trials:\n    //\n    //            zoom 2        zoom 8        ~1:1\n    //   1.0      1.34x up      1.34x up      1.86x up\n    //   0.5      0.67x (none)  0.67x (none)  0.93x -> full res\n    //   0.25     0.33x         0.33x         0.93x\n    //\n    // 0.5 is what gives \"never upscaled below native, full resolution at 1:1\".\n    // 0.25 is not better - it jumps two rungs finer and fetches ~4x the tiles\n    // for no visible gain, and tiles are not cached by the ingress.\n    minPixelRatio: 0.5,\n    // Wait for the view to settle before pulling new tiles (less churn).\n    immediateRender: false,\n    animationTime: 0.4,\n    // Release memory aggressively: cap the tile cache so tiles outside the\n    // current view (e.g. the coarser levels left behind after zooming in) are\n    // evicted instead of accumulating. Large whole-slide tiles — doubled when\n    // the colormap pipeline keeps a recolored copy — make an unbounded cache\n    // costly. Tunable; lower = less memory, more re-fetch on pan-back.\n    // Stacks keep many slices resident (the whole stack is background-loaded),\n    // so they get a much larger tile budget — otherwise switching slices evicts\n    // each other's tiles and scrubbing back re-fetches. Scaled to the resident\n    // slice count; single images keep the lean default.\n    maxImageCacheCount: input.sliceCount > 1 ? Math.min(2400, Math.max(600, input.maxSlices * 40)) : 150,\n  };\n}\n"]}