@jax-data-science/sci-image-visualizer 0.1.0

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

@@ -0,0 +1,126 @@
+/**
+ * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn
+ * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label
+ * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes
+ * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and
+ * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).
+ *
+ * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays
+ * updated on every `camera3d.changed`, but this one accepts pointer input.
+ */
+import { projectPoint } from './napari-axes-labels';
+const DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };
+export class NapariVolumeZHandle {
+    constructor(host, camera3d, opts) {
+        this.host = host;
+        this.camera3d = camera3d;
+        this.visible = true;
+        this.dragging = false;
+        this.startY = 0;
+        this.startScale = 1;
+        this.onPointerDown = (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            this.dragging = true;
+            this.startY = e.clientY;
+            this.startScale = this.opts.getScale();
+            this.el.setPointerCapture?.(e.pointerId);
+        };
+        this.onPointerMove = (e) => {
+            if (!this.dragging)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.
+            const dy = e.clientY - this.startY;
+            const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);
+            const next = Math.min(this.opts.maxScale, Math.max(this.opts.minScale, this.startScale * factor));
+            this.opts.setScale(next);
+            this.reposition();
+        };
+        this.onPointerUp = (e) => {
+            if (!this.dragging)
+                return;
+            this.dragging = false;
+            if (this.el.hasPointerCapture?.(e.pointerId))
+                this.el.releasePointerCapture?.(e.pointerId);
+        };
+        this.onDoubleClick = (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            this.opts.setScale(1);
+            this.reposition();
+        };
+        this.opts = { ...DEFAULTS, ...opts };
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        this.el = document.createElement('div');
+        Object.assign(this.el.style, {
+            position: 'absolute',
+            zIndex: '31',
+            width: '22px',
+            height: '22px',
+            marginLeft: '-11px',
+            marginTop: '-11px',
+            borderRadius: '50%',
+            background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)
+            border: '1.5px solid #fff',
+            boxShadow: '0 0 4px rgba(0,0,0,0.6)',
+            color: '#fff',
+            font: '13px sans-serif',
+            lineHeight: '20px',
+            textAlign: 'center',
+            cursor: 'ns-resize',
+            touchAction: 'none',
+            userSelect: 'none',
+        });
+        this.el.textContent = '↕';
+        this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';
+        this.host.appendChild(this.el);
+        this.el.addEventListener('pointerdown', this.onPointerDown);
+        this.el.addEventListener('pointermove', this.onPointerMove);
+        this.el.addEventListener('pointerup', this.onPointerUp);
+        this.el.addEventListener('pointercancel', this.onPointerUp);
+        this.el.addEventListener('dblclick', this.onDoubleClick);
+        this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(() => this.reposition());
+            this.resizeObserver.observe(this.host);
+        }
+        this.reposition();
+    }
+    setVisible(visible) {
+        this.visible = visible;
+        this.reposition();
+    }
+    /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after
+     *  the host applies a new scale (so the grip follows the growing/shrinking box). */
+    reposition() {
+        const vw = this.host.clientWidth;
+        const vh = this.host.clientHeight;
+        if (!this.visible || vw <= 0 || vh <= 0) {
+            this.el.style.display = 'none';
+            return;
+        }
+        const mvp = this.camera3d.viewProjection(vw, vh);
+        const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);
+        if (!s.visible) {
+            this.el.style.display = 'none';
+            return;
+        }
+        this.el.style.display = '';
+        this.el.style.left = `${s.x}px`;
+        this.el.style.top = `${s.y}px`;
+    }
+    destroy() {
+        this.disconnectCamera();
+        this.resizeObserver?.disconnect();
+        this.el.removeEventListener('pointerdown', this.onPointerDown);
+        this.el.removeEventListener('pointermove', this.onPointerMove);
+        this.el.removeEventListener('pointerup', this.onPointerUp);
+        this.el.removeEventListener('pointercancel', this.onPointerUp);
+        this.el.removeEventListener('dblclick', this.onDoubleClick);
+        this.el.parentNode?.removeChild(this.el);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-z-handle.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-z-handle.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Draggable Z-height handle for the napari-js WebGPU volume (jit-ui#102). A small DOM grip is drawn\n * over the 3D canvas at the projected top-face centre of the volume box (reusing the axes-label\n * {@link projectPoint} projection, so it tracks the box as the volume orbits). Dragging it up makes\n * the volume taller, down makes it flatter — the host maps the drag to a Z-scale factor and\n * restretches the volume + axes live (only the model matrix changes; the voxel texture is untouched).\n *\n * Direct-manipulation counterpart of {@link NapariAxesLabels}: both are absolute-positioned overlays\n * updated on every `camera3d.changed`, but this one accepts pointer input.\n */\nimport { AxesLabelCamera3D, projectPoint } from './napari-axes-labels';\n\nexport interface VolumeZHandleOptions {\n  /** Current top-face-centre world point (the box is centred at the origin, so `[0, 0, +halfZ]`). */\n  topAnchor: () => [number, number, number];\n  /** The current Z-scale factor (1 = the volume's default proportions). */\n  getScale: () => number;\n  /** Apply a new Z-scale factor — the host restretches the volume + axes and repositions overlays. */\n  setScale: (scale: number) => void;\n  /** Vertical drag (px) for one doubling/halving of the Z height. Larger = less sensitive. */\n  pixelsPerDouble?: number;\n  /** Clamp for the Z-scale factor. */\n  minScale?: number;\n  maxScale?: number;\n}\n\nconst DEFAULTS = { pixelsPerDouble: 180, minScale: 0.1, maxScale: 10 };\n\nexport class NapariVolumeZHandle {\n  private readonly el: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private readonly opts: Required<VolumeZHandleOptions>;\n  private visible = true;\n  private dragging = false;\n  private startY = 0;\n  private startScale = 1;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: AxesLabelCamera3D,\n    opts: VolumeZHandleOptions,\n  ) {\n    this.opts = { ...DEFAULTS, ...opts };\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      zIndex: '31',\n      width: '22px',\n      height: '22px',\n      marginLeft: '-11px',\n      marginTop: '-11px',\n      borderRadius: '50%',\n      background: 'rgba(102,140,255,0.85)', // matches the Z axis colour (#668cff)\n      border: '1.5px solid #fff',\n      boxShadow: '0 0 4px rgba(0,0,0,0.6)',\n      color: '#fff',\n      font: '13px sans-serif',\n      lineHeight: '20px',\n      textAlign: 'center',\n      cursor: 'ns-resize',\n      touchAction: 'none',\n      userSelect: 'none',\n    } as Partial<CSSStyleDeclaration>);\n    this.el.textContent = '↕';\n    this.el.title = 'Drag to change the volume height (Z). Double-click to reset.';\n    this.host.appendChild(this.el);\n\n    this.el.addEventListener('pointerdown', this.onPointerDown);\n    this.el.addEventListener('pointermove', this.onPointerMove);\n    this.el.addEventListener('pointerup', this.onPointerUp);\n    this.el.addEventListener('pointercancel', this.onPointerUp);\n    this.el.addEventListener('dblclick', this.onDoubleClick);\n\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.reposition());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.reposition());\n      this.resizeObserver.observe(this.host);\n    }\n    this.reposition();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.reposition();\n  }\n\n  /** Reproject the handle to the current top-face anchor. Called on camera move, resize, and after\n   *  the host applies a new scale (so the grip follows the growing/shrinking box). */\n  reposition(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      this.el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    const s = projectPoint(mvp, this.opts.topAnchor(), vw, vh);\n    if (!s.visible) {\n      this.el.style.display = 'none';\n      return;\n    }\n    this.el.style.display = '';\n    this.el.style.left = `${s.x}px`;\n    this.el.style.top = `${s.y}px`;\n  }\n\n  private readonly onPointerDown = (e: PointerEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.dragging = true;\n    this.startY = e.clientY;\n    this.startScale = this.opts.getScale();\n    this.el.setPointerCapture?.(e.pointerId);\n  };\n\n  private readonly onPointerMove = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    e.preventDefault();\n    e.stopPropagation();\n    // Up (negative dy) → taller. Exponential so each `pixelsPerDouble` px doubles/halves the height.\n    const dy = e.clientY - this.startY;\n    const factor = Math.pow(2, -dy / this.opts.pixelsPerDouble);\n    const next = Math.min(\n      this.opts.maxScale,\n      Math.max(this.opts.minScale, this.startScale * factor),\n    );\n    this.opts.setScale(next);\n    this.reposition();\n  };\n\n  private readonly onPointerUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    this.dragging = false;\n    if (this.el.hasPointerCapture?.(e.pointerId)) this.el.releasePointerCapture?.(e.pointerId);\n  };\n\n  private readonly onDoubleClick = (e: MouseEvent): void => {\n    e.preventDefault();\n    e.stopPropagation();\n    this.opts.setScale(1);\n    this.reposition();\n  };\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.el.removeEventListener('pointerdown', this.onPointerDown);\n    this.el.removeEventListener('pointermove', this.onPointerMove);\n    this.el.removeEventListener('pointerup', this.onPointerUp);\n    this.el.removeEventListener('pointercancel', this.onPointerUp);\n    this.el.removeEventListener('dblclick', this.onDoubleClick);\n    this.el.parentNode?.removeChild(this.el);\n  }\n}\n"]}

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

@@ -0,0 +1,143 @@
+export class DisplayPipeline {
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Apply the current display pipeline to an RGBA buffer in place; returns
+     * whether any opaque pixel was written.
+     *  - Grayscale: intensity → window + gamma + invert → colormap LUT.
+     *  - RGB/multichannel: additive pseudo-colour merge — each visible channel's
+     *    windowed intensity is tinted by its assigned colour and summed (Fiji
+     *    "Merge Channels"). Defaults (R=red, G=green, B=blue) are the identity.
+     */
+    applyToRgba(d) {
+        let changed = false;
+        const channelStates = this.host.channelStates();
+        const invertBg = this.host.invertBg();
+        if (this.host.isGrayscale()) {
+            const lut = this.host.colorLut();
+            if (!lut)
+                return false;
+            const ch = channelStates[0];
+            const wMin = ch ? ch.min : 0;
+            const wSpan = ch && ch.max > ch.min ? ch.max - ch.min : 255;
+            const invGamma = ch && ch.gamma > 0 ? 1 / ch.gamma : 1;
+            // Precompute raw(0..255) -> final RGB once (256 window+gamma+invert+colormap
+            // evaluations) and map each pixel by table lookup — a Math.pow per pixel
+            // (~262k/tile) made the window/gamma sliders crawl on large stacks.
+            const rL = new Uint8ClampedArray(256);
+            const gL = new Uint8ClampedArray(256);
+            const bL = new Uint8ClampedArray(256);
+            for (let raw = 0; raw < 256; raw++) {
+                let t = (raw - wMin) / wSpan;
+                t = t < 0 ? 0 : t > 1 ? 1 : t;
+                if (invGamma !== 1)
+                    t = Math.pow(t, invGamma);
+                let v = Math.round(t * 255);
+                if (invertBg)
+                    v = 255 - v;
+                const c = lut[v];
+                rL[raw] = c[0];
+                gL[raw] = c[1];
+                bL[raw] = c[2];
+            }
+            for (let i = 0; i < d.length; i += 4) {
+                if (d[i + 3] === 0)
+                    continue;
+                // maxRgb (contracts/intensity) inlined on purpose: this loop runs
+                // ~262k times per tile on every recolor.
+                const raw = d[i] >= d[i + 1] ? (d[i] >= d[i + 2] ? d[i] : d[i + 2]) : d[i + 1] >= d[i + 2] ? d[i + 1] : d[i + 2];
+                d[i] = rL[raw];
+                d[i + 1] = gL[raw];
+                d[i + 2] = bL[raw];
+                changed = true;
+            }
+        }
+        else {
+            const chans = [channelStates[0], channelStates[1], channelStates[2]];
+            const tints = chans.map((c) => this.tint01(c));
+            for (let i = 0; i < d.length; i += 4) {
+                if (d[i + 3] === 0)
+                    continue;
+                let oR = 0, oG = 0, oB = 0;
+                for (let k = 0; k < 3; k++) {
+                    const c = chans[k];
+                    if (c && !c.visible)
+                        continue;
+                    const v = this.channelIntensity(d[i + k], c);
+                    const tint = tints[k];
+                    oR += v * tint[0];
+                    oG += v * tint[1];
+                    oB += v * tint[2];
+                }
+                if (oR > 255)
+                    oR = 255;
+                if (oG > 255)
+                    oG = 255;
+                if (oB > 255)
+                    oB = 255;
+                if (invertBg) {
+                    oR = 255 - oR;
+                    oG = 255 - oG;
+                    oB = 255 - oB;
+                }
+                d[i] = oR;
+                d[i + 1] = oG;
+                d[i + 2] = oB;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+    /** Precomputed lum(0..255) → tinted-RGB lookup for a channel's window/gamma/
+     *  colour. Building it costs 256 channelIntensity() calls; using it makes a
+     *  full-tile recolor ~262k array lookups instead of ~262k Math.pow() calls. */
+    channelRgbLut(st) {
+        const r = new Uint8ClampedArray(256);
+        const g = new Uint8ClampedArray(256);
+        const b = new Uint8ClampedArray(256);
+        const [tr, tg, tb] = this.tint01(st);
+        for (let lum = 0; lum < 256; lum++) {
+            const v = this.channelIntensity(lum, st);
+            r[lum] = v * tr;
+            g[lum] = v * tg;
+            b[lum] = v * tb;
+        }
+        return { r, g, b };
+    }
+    /** Windowed + gamma intensity (0..255) for a channel, ignoring tint/invert. */
+    channelIntensity(val, c) {
+        if (!c)
+            return val;
+        const span = c.max > c.min ? c.max - c.min : 0;
+        if (!span)
+            return 0;
+        let t = (val - c.min) / span;
+        t = t < 0 ? 0 : t > 1 ? 1 : t;
+        if (c.gamma > 0 && c.gamma !== 1)
+            t = Math.pow(t, 1 / c.gamma);
+        return t * 255;
+    }
+    /** A channel's pseudo-colour tint as [r,g,b] in 0..1 (default white). */
+    tint01(c) {
+        const m = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(c?.color ?? '');
+        return m ? [parseInt(m[1], 16) / 255, parseInt(m[2], 16) / 255, parseInt(m[3], 16) / 255] : [1, 1, 1];
+    }
+    /** True when any RGB channel is windowed/hidden/gamma'd/re-tinted or the
+     *  background is inverted — otherwise the tile passes through unchanged. */
+    rgbNeedsRecolor() {
+        if (this.host.invertBg())
+            return true;
+        const defaults = ['#ff0000', '#00ff00', '#0000ff'];
+        const channelStates = this.host.channelStates();
+        for (let k = 0; k < 3; k++) {
+            const c = channelStates[k];
+            if (c && (!c.visible || c.min !== 0 || c.max !== 255 || c.gamma !== 1 ||
+                (c.color || '').toLowerCase() !== defaults[k])) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-pipeline.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/display-pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { Rgb } from '../../contracts/colormap-lut';\n\n/**\n * The OSD pixel display pipeline (refactoring plan, Step 4 — a pure move of\n * the recolor math out of the visualizer service). Stateless: every call reads\n * the current display state through the host closures, exactly like the moved\n * code read the service's fields. Shared by tile recoloring and the composite\n * export so they stay identical.\n */\nexport interface DisplayPipelineHost {\n  /** Grayscale image (colormap LUT path) vs RGB/multichannel (additive tint). */\n  isGrayscale(): boolean;\n  /** 256-entry colormap LUT (grayscale path); null while options resolve. */\n  colorLut(): Rgb[] | null;\n  /** Latest per-channel display state from the store. */\n  channelStates(): IChannelState[];\n  /** Inverted background (white = zero). */\n  invertBg(): boolean;\n}\n\nexport class DisplayPipeline {\n  constructor(private host: DisplayPipelineHost) {}\n\n  /**\n   * Apply the current display pipeline to an RGBA buffer in place; returns\n   * whether any opaque pixel was written.\n   *  - Grayscale: intensity → window + gamma + invert → colormap LUT.\n   *  - RGB/multichannel: additive pseudo-colour merge — each visible channel's\n   *    windowed intensity is tinted by its assigned colour and summed (Fiji\n   *    \"Merge Channels\"). Defaults (R=red, G=green, B=blue) are the identity.\n   */\n  applyToRgba(d: Uint8ClampedArray): boolean {\n    let changed = false;\n    const channelStates = this.host.channelStates();\n    const invertBg = this.host.invertBg();\n    if (this.host.isGrayscale()) {\n      const lut = this.host.colorLut();\n      if (!lut) return false;\n      const ch = channelStates[0];\n      const wMin = ch ? ch.min : 0;\n      const wSpan = ch && ch.max > ch.min ? ch.max - ch.min : 255;\n      const invGamma = ch && ch.gamma > 0 ? 1 / ch.gamma : 1;\n      // Precompute raw(0..255) -> final RGB once (256 window+gamma+invert+colormap\n      // evaluations) and map each pixel by table lookup — a Math.pow per pixel\n      // (~262k/tile) made the window/gamma sliders crawl on large stacks.\n      const rL = new Uint8ClampedArray(256);\n      const gL = new Uint8ClampedArray(256);\n      const bL = new Uint8ClampedArray(256);\n      for (let raw = 0; raw < 256; raw++) {\n        let t = (raw - wMin) / wSpan;\n        t = t < 0 ? 0 : t > 1 ? 1 : t;\n        if (invGamma !== 1) t = Math.pow(t, invGamma);\n        let v = Math.round(t * 255);\n        if (invertBg) v = 255 - v;\n        const c = lut[v];\n        rL[raw] = c[0];\n        gL[raw] = c[1];\n        bL[raw] = c[2];\n      }\n      for (let i = 0; i < d.length; i += 4) {\n        if (d[i + 3] === 0) continue;\n        // maxRgb (contracts/intensity) inlined on purpose: this loop runs\n        // ~262k times per tile on every recolor.\n        const raw =\n          d[i] >= d[i + 1] ? (d[i] >= d[i + 2] ? d[i] : d[i + 2]) : d[i + 1] >= d[i + 2] ? d[i + 1] : d[i + 2];\n        d[i] = rL[raw];\n        d[i + 1] = gL[raw];\n        d[i + 2] = bL[raw];\n        changed = true;\n      }\n    } else {\n      const chans = [channelStates[0], channelStates[1], channelStates[2]];\n      const tints = chans.map((c) => this.tint01(c));\n      for (let i = 0; i < d.length; i += 4) {\n        if (d[i + 3] === 0) continue;\n        let oR = 0, oG = 0, oB = 0;\n        for (let k = 0; k < 3; k++) {\n          const c = chans[k];\n          if (c && !c.visible) continue;\n          const v = this.channelIntensity(d[i + k], c);\n          const tint = tints[k];\n          oR += v * tint[0];\n          oG += v * tint[1];\n          oB += v * tint[2];\n        }\n        if (oR > 255) oR = 255;\n        if (oG > 255) oG = 255;\n        if (oB > 255) oB = 255;\n        if (invertBg) { oR = 255 - oR; oG = 255 - oG; oB = 255 - oB; }\n        d[i] = oR;\n        d[i + 1] = oG;\n        d[i + 2] = oB;\n        changed = true;\n      }\n    }\n    return changed;\n  }\n\n  /** Precomputed lum(0..255) → tinted-RGB lookup for a channel's window/gamma/\n   *  colour. Building it costs 256 channelIntensity() calls; using it makes a\n   *  full-tile recolor ~262k array lookups instead of ~262k Math.pow() calls. */\n  channelRgbLut(st?: IChannelState): { r: Uint8ClampedArray; g: Uint8ClampedArray; b: Uint8ClampedArray } {\n    const r = new Uint8ClampedArray(256);\n    const g = new Uint8ClampedArray(256);\n    const b = new Uint8ClampedArray(256);\n    const [tr, tg, tb] = this.tint01(st);\n    for (let lum = 0; lum < 256; lum++) {\n      const v = this.channelIntensity(lum, st);\n      r[lum] = v * tr;\n      g[lum] = v * tg;\n      b[lum] = v * tb;\n    }\n    return { r, g, b };\n  }\n\n  /** Windowed + gamma intensity (0..255) for a channel, ignoring tint/invert. */\n  channelIntensity(val: number, c?: IChannelState): number {\n    if (!c) return val;\n    const span = c.max > c.min ? c.max - c.min : 0;\n    if (!span) return 0;\n    let t = (val - c.min) / span;\n    t = t < 0 ? 0 : t > 1 ? 1 : t;\n    if (c.gamma > 0 && c.gamma !== 1) t = Math.pow(t, 1 / c.gamma);\n    return t * 255;\n  }\n\n  /** A channel's pseudo-colour tint as [r,g,b] in 0..1 (default white). */\n  tint01(c?: IChannelState): [number, number, number] {\n    const m = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(c?.color ?? '');\n    return m ? [parseInt(m[1], 16) / 255, parseInt(m[2], 16) / 255, parseInt(m[3], 16) / 255] : [1, 1, 1];\n  }\n\n  /** True when any RGB channel is windowed/hidden/gamma'd/re-tinted or the\n   *  background is inverted — otherwise the tile passes through unchanged. */\n  rgbNeedsRecolor(): boolean {\n    if (this.host.invertBg()) return true;\n    const defaults = ['#ff0000', '#00ff00', '#0000ff'];\n    const channelStates = this.host.channelStates();\n    for (let k = 0; k < 3; k++) {\n      const c = channelStates[k];\n      if (\n        c && (!c.visible || c.min !== 0 || c.max !== 255 || c.gamma !== 1 ||\n          (c.color || '').toLowerCase() !== defaults[k])\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n}\n"]}

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

@@ -0,0 +1,217 @@
+import { firstValueFrom, from, of } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+import { buildTileUrl, fetchTileRgba } from './tile-client';
+import { histogram256, maxRgb } from '../../contracts/intensity';
+export class HistogramSampler {
+    constructor(http, api, host) {
+        this.http = http;
+        this.api = api;
+        this.host = host;
+        /** 256-bin intensity histogram per z-slice, from sampled tiles. */
+        this.sliceHistograms = new Map();
+        /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}`. */
+        this.nativeHistograms = new Map();
+        /** Per-app-load cache-buster for `/histogram` — the server marks the
+         *  response cacheable for 24h, and a hard refresh can't bust a post-load
+         *  XHR. A token stable within a session but new on each full load keeps the
+         *  in-session dedup (via `nativeHistograms`) while always reflecting the
+         *  live backend after a reload. */
+        this.histCacheBuster = Date.now();
+    }
+    /** The sampled histogram for one channel of slice z, or null until the
+     *  async sampling resolves (or if it was skipped). */
+    get(z, channelIndex) {
+        return this.sliceHistograms.get(z)?.[channelIndex] ?? null;
+    }
+    /** Drop everything (teardown / image switch). */
+    clear() {
+        this.sliceHistograms.clear();
+        this.nativeHistograms.clear();
+    }
+    /**
+     * Per-channel intensity histograms for multichannel images: sample each
+     * channel's single-band tiles at the coarsest real level and bin the
+     * luminance. Fire-and-forget.
+     */
+    async computeMultiChannelHistograms(d, infoB64, z) {
+        try {
+            const t = d.tileSize;
+            // Sample the COARSEST real level (per-channel tiles exist only at real
+            // resolutions; the coarsest is small enough to bin even for whole-slides).
+            const res = Math.max(0, this.host.realLevels() - 1);
+            const lvl = d.levels?.[res];
+            const lw = lvl?.width ?? d.width;
+            const lh = lvl?.height ?? d.height;
+            const cols = Math.max(1, Math.ceil(lw / t));
+            const rows = Math.max(1, Math.ceil(lh / t));
+            if (cols * rows > 64)
+                return; // even the coarsest real level is too big
+            const nCh = this.host.channelCount(d);
+            if (nCh < 1)
+                return;
+            const counts = Array.from({ length: nCh }, () => new Array(256).fill(0));
+            const jobs = [];
+            for (let row = 0; row < rows; row++) {
+                for (let col = 0; col < cols; col++) {
+                    for (let c = 0; c < nCh; c++) {
+                        const url = buildTileUrl(this.api, infoB64, { res, col, row, z, tileSize: t, channel: c });
+                        jobs.push((async () => {
+                            try {
+                                const img = await fetchTileRgba(this.http, url, 20000);
+                                if (!img)
+                                    return;
+                                const data = img.data;
+                                const cc = counts[c];
+                                for (let i = 0; i < data.length; i += 4) {
+                                    if (data[i + 3] === 0)
+                                        continue;
+                                    cc[maxRgb(data[i], data[i + 1], data[i + 2])]++;
+                                }
+                            }
+                            catch (err) {
+                                // Skip this tile — the histogram is just missing its counts.
+                                console.warn('[viz:histogram] channel tile sample failed, skipping', url, err);
+                            }
+                        })());
+                    }
+                }
+            }
+            await Promise.all(jobs);
+            this.sliceHistograms.set(z, counts.map((c) => histogram256(c)));
+            this.host.onChannelHistogramsSampled();
+        }
+        catch (err) {
+            // Leave histograms unset (the pane shows empty) — but say why.
+            console.warn('[viz:histogram] multichannel histogram sampling failed', err);
+        }
+    }
+    /**
+     * Compute a per-image intensity window [min,max] for grayscale auto-ranging,
+     * mirroring the heatmap's auto-stretch. Two constraints force the sampling
+     * strategy:
+     *  - The window MUST be in the same value space as the displayed tiles: the
+     *    `/preview` endpoint is server-normalized while `/tile` serves raw
+     *    un-normalized 8-bit — a window from the preview wouldn't match.
+     *  - It must read FULL-RESOLUTION tiles, not a downsampled overview:
+     *    averaging sparse low values (label masks) toward 0 wipes the signal.
+     * So we sample the full-res level across the whole image — bounded to 64
+     * tiles (a huge grayscale image samples the coarsest overview for histograms
+     * only). Fire-and-forget; failures leave the window unset (identity 0..255).
+     */
+    async computeImageWindow(d, infoB64, z) {
+        const gray = this.host.isGrayscale();
+        try {
+            const t = d.tileSize;
+            // Sample full-resolution when the grid is small (accurate for the grayscale
+            // auto-window); otherwise sample the coarsest overview just for histograms
+            // (whole-slide images). RGB only needs the histograms, not an auto-window.
+            let res = 0;
+            let cols = Math.max(1, Math.ceil(d.width / t));
+            let rows = Math.max(1, Math.ceil(d.height / t));
+            let fullRes = true;
+            if (cols * rows > 64) {
+                res = Math.max(0, (d.levels?.length ?? 1) - 1);
+                const lvl = d.levels?.[res];
+                cols = Math.max(1, Math.ceil((lvl?.width ?? d.width) / t));
+                rows = Math.max(1, Math.ceil((lvl?.height ?? d.height) / t));
+                fullRes = false;
+                if (cols * rows > 36)
+                    return; // even the coarsest is too big — give up
+            }
+            const coords = [];
+            for (let row = 0; row < rows; row++) {
+                for (let col = 0; col < cols; col++)
+                    coords.push([col, row]);
+            }
+            let min = 255;
+            let max = 0;
+            const cR = new Array(256).fill(0);
+            const cG = gray ? null : new Array(256).fill(0);
+            const cB = gray ? null : new Array(256).fill(0);
+            await Promise.all(coords.map(async ([col, row]) => {
+                const url = buildTileUrl(this.api, infoB64, { res, col, row, z, tileSize: t });
+                try {
+                    const img = await fetchTileRgba(this.http, url, 20000);
+                    if (!img)
+                        return;
+                    const data = img.data;
+                    for (let i = 0; i < data.length; i += 4) {
+                        if (data[i + 3] === 0)
+                            continue; // skip transparent padding
+                        if (gray) {
+                            const v = maxRgb(data[i], data[i + 1], data[i + 2]);
+                            if (v < min)
+                                min = v;
+                            if (v > max)
+                                max = v;
+                            cR[v]++;
+                        }
+                        else {
+                            cR[data[i]]++;
+                            cG[data[i + 1]]++;
+                            cB[data[i + 2]]++;
+                        }
+                    }
+                }
+                catch (err) {
+                    // Skip this tile — window/histogram just lose its samples.
+                    console.warn('[viz:window] tile sample failed, skipping', url, err);
+                }
+            }));
+            // Cache per-channel histograms: grayscale → [intensity]; RGB → [R, G, B].
+            this.sliceHistograms.set(z, gray ? [histogram256(cR)] : [histogram256(cR), histogram256(cG), histogram256(cB)]);
+            // Grayscale auto-window — only from full-res samples (coarsest averaging
+            // is inaccurate); the host seeds the channel or re-invalidates.
+            if (gray && fullRes && max > min && (min > 0 || max < 255)) {
+                this.host.onGrayWindowSampled(min, max);
+            }
+        }
+        catch (err) {
+            console.warn('[viz:window] per-image window compute failed — using identity 0..255', err);
+        }
+    }
+    /**
+     * Native-bit-depth histogram for >8-bit images, from the server `/histogram`
+     * endpoint (the 8-bit canvas tiles can't carry 16-bit values). Cached per
+     * slice+channel for the session.
+     */
+    native$(infoB64, z, channel, bins) {
+        const key = `${z}|${channel}`;
+        const cached = this.nativeHistograms.get(key);
+        if (cached)
+            return of(cached);
+        return from(this.fetchNative(infoB64, z, channel, bins, key));
+    }
+    /** Fetch + cache one channel's native histogram from `GET /histogram`. */
+    async fetchNative(infoB64, z, channel, bins, key) {
+        const url = `${this.api}histogram?info=${infoB64}&channel=${channel}&z=${z}&bins=${bins}&_=${this.histCacheBuster}`;
+        try {
+            // HttpClient calls get auth via the Angular interceptor (unlike OSD's own
+            // ajax tile loader, which needs authHeaders) — mirror the other fetches.
+            const hi = await firstValueFrom(this.http
+                .get(url)
+                .pipe(timeout(45000)));
+            if (!hi || !hi.counts)
+                return null;
+            const out = {
+                // Native bin left-edges: rangeMin + i*binWidth.
+                bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),
+                counts: hi.counts,
+                max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),
+                bitDepth: hi.bitDepth,
+                rangeMin: hi.rangeMin,
+                rangeMax: hi.rangeMax,
+                observedMin: hi.observedMin,
+                observedMax: hi.observedMax,
+            };
+            this.nativeHistograms.set(key, out);
+            return out;
+        }
+        catch (err) {
+            // 202 (still caching) or a transient error → null; the pane retries.
+            console.warn('[viz:histogram] native histogram fetch failed', err);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"histogram-sampler.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/osd/histogram-sampler.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Observable, firstValueFrom, from, of } from 'rxjs';\nimport { timeout } from 'rxjs/operators';\n\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { buildTileUrl, fetchTileRgba } from './tile-client';\nimport { histogram256, maxRgb } from '../../contracts/intensity';\n\n/**\n * Histogram + auto-window sampling for the OSD backend (refactoring plan,\n * Step 4 — a pure move out of the visualizer service). Owns the per-slice\n * 8-bit histograms (sampled from displayed tiles) and the native-bit-depth\n * histograms (fetched from the server `/histogram` endpoint). Read-only with\n * respect to the tile/display pipeline.\n */\n\n/** The descriptor fields the samplers read (structurally satisfied by the\n *  service's TileDescriptor). */\nexport interface SampledDescriptor {\n  width: number;\n  height: number;\n  tileSize: number;\n  channels?: number;\n  levels?: Array<{ width: number; height: number }>;\n}\n\nexport interface HistogramSamplerHost {\n  /** Real Bio-Formats levels (per-channel tiles exist only there). */\n  realLevels(): number;\n  /** Channel count for the multichannel sampler. */\n  channelCount(d: SampledDescriptor): number;\n  /** Grayscale (intensity histogram + auto-window) vs RGB (R/G/B histograms). */\n  isGrayscale(): boolean;\n  /** Histograms landed — nudge the pane to re-read (its retry window may have\n   *  lapsed). */\n  onChannelHistogramsSampled(): void;\n  /** A grayscale auto-window was measured from full-res tiles — seed the\n   *  Intensity channel (or re-invalidate if the user already windowed). */\n  onGrayWindowSampled(min: number, max: number): void;\n}\n\nexport class HistogramSampler {\n  /** 256-bin intensity histogram per z-slice, from sampled tiles. */\n  private sliceHistograms = new Map<number, IHistogram[]>();\n  /** Native-bit-depth histograms from `/histogram`, keyed `${z}|${channel}`. */\n  private nativeHistograms = new Map<string, IHistogram>();\n  /** Per-app-load cache-buster for `/histogram` — the server marks the\n   *  response cacheable for 24h, and a hard refresh can't bust a post-load\n   *  XHR. A token stable within a session but new on each full load keeps the\n   *  in-session dedup (via `nativeHistograms`) while always reflecting the\n   *  live backend after a reload. */\n  private readonly histCacheBuster = Date.now();\n\n  constructor(\n    private http: HttpClient,\n    private api: string,\n    private host: HistogramSamplerHost,\n  ) {}\n\n  /** The sampled histogram for one channel of slice z, or null until the\n   *  async sampling resolves (or if it was skipped). */\n  get(z: number, channelIndex: number): IHistogram | null {\n    return this.sliceHistograms.get(z)?.[channelIndex] ?? null;\n  }\n\n  /** Drop everything (teardown / image switch). */\n  clear(): void {\n    this.sliceHistograms.clear();\n    this.nativeHistograms.clear();\n  }\n\n  /**\n   * Per-channel intensity histograms for multichannel images: sample each\n   * channel's single-band tiles at the coarsest real level and bin the\n   * luminance. Fire-and-forget.\n   */\n  async computeMultiChannelHistograms(d: SampledDescriptor, infoB64: string, z: number): Promise<void> {\n    try {\n      const t = d.tileSize;\n      // Sample the COARSEST real level (per-channel tiles exist only at real\n      // resolutions; the coarsest is small enough to bin even for whole-slides).\n      const res = Math.max(0, this.host.realLevels() - 1);\n      const lvl = d.levels?.[res];\n      const lw = lvl?.width ?? d.width;\n      const lh = lvl?.height ?? d.height;\n      const cols = Math.max(1, Math.ceil(lw / t));\n      const rows = Math.max(1, Math.ceil(lh / t));\n      if (cols * rows > 64) return; // even the coarsest real level is too big\n      const nCh = this.host.channelCount(d);\n      if (nCh < 1) return;\n      const counts: number[][] = Array.from({ length: nCh }, () => new Array(256).fill(0));\n      const jobs: Array<Promise<void>> = [];\n      for (let row = 0; row < rows; row++) {\n        for (let col = 0; col < cols; col++) {\n          for (let c = 0; c < nCh; c++) {\n            const url = buildTileUrl(this.api, infoB64, { res, col, row, z, tileSize: t, channel: c });\n            jobs.push(\n              (async () => {\n                try {\n                  const img = await fetchTileRgba(this.http, url, 20000);\n                  if (!img) return;\n                  const data = img.data;\n                  const cc = counts[c];\n                  for (let i = 0; i < data.length; i += 4) {\n                    if (data[i + 3] === 0) continue;\n                    cc[maxRgb(data[i], data[i + 1], data[i + 2])]++;\n                  }\n                } catch (err) {\n                  // Skip this tile — the histogram is just missing its counts.\n                  console.warn('[viz:histogram] channel tile sample failed, skipping', url, err);\n                }\n              })(),\n            );\n          }\n        }\n      }\n      await Promise.all(jobs);\n      this.sliceHistograms.set(z, counts.map((c) => histogram256(c)));\n      this.host.onChannelHistogramsSampled();\n    } catch (err) {\n      // Leave histograms unset (the pane shows empty) — but say why.\n      console.warn('[viz:histogram] multichannel histogram sampling failed', err);\n    }\n  }\n\n  /**\n   * Compute a per-image intensity window [min,max] for grayscale auto-ranging,\n   * mirroring the heatmap's auto-stretch. Two constraints force the sampling\n   * strategy:\n   *  - The window MUST be in the same value space as the displayed tiles: the\n   *    `/preview` endpoint is server-normalized while `/tile` serves raw\n   *    un-normalized 8-bit — a window from the preview wouldn't match.\n   *  - It must read FULL-RESOLUTION tiles, not a downsampled overview:\n   *    averaging sparse low values (label masks) toward 0 wipes the signal.\n   * So we sample the full-res level across the whole image — bounded to 64\n   * tiles (a huge grayscale image samples the coarsest overview for histograms\n   * only). Fire-and-forget; failures leave the window unset (identity 0..255).\n   */\n  async computeImageWindow(d: SampledDescriptor, infoB64: string, z: number): Promise<void> {\n    const gray = this.host.isGrayscale();\n    try {\n      const t = d.tileSize;\n      // Sample full-resolution when the grid is small (accurate for the grayscale\n      // auto-window); otherwise sample the coarsest overview just for histograms\n      // (whole-slide images). RGB only needs the histograms, not an auto-window.\n      let res = 0;\n      let cols = Math.max(1, Math.ceil(d.width / t));\n      let rows = Math.max(1, Math.ceil(d.height / t));\n      let fullRes = true;\n      if (cols * rows > 64) {\n        res = Math.max(0, (d.levels?.length ?? 1) - 1);\n        const lvl = d.levels?.[res];\n        cols = Math.max(1, Math.ceil((lvl?.width ?? d.width) / t));\n        rows = Math.max(1, Math.ceil((lvl?.height ?? d.height) / t));\n        fullRes = false;\n        if (cols * rows > 36) return; // even the coarsest is too big — give up\n      }\n      const coords: Array<[number, number]> = [];\n      for (let row = 0; row < rows; row++) {\n        for (let col = 0; col < cols; col++) coords.push([col, row]);\n      }\n      let min = 255;\n      let max = 0;\n      const cR = new Array(256).fill(0);\n      const cG = gray ? null : new Array(256).fill(0);\n      const cB = gray ? null : new Array(256).fill(0);\n      await Promise.all(\n        coords.map(async ([col, row]) => {\n          const url = buildTileUrl(this.api, infoB64, { res, col, row, z, tileSize: t });\n          try {\n            const img = await fetchTileRgba(this.http, url, 20000);\n            if (!img) return;\n            const data = img.data;\n            for (let i = 0; i < data.length; i += 4) {\n              if (data[i + 3] === 0) continue; // skip transparent padding\n              if (gray) {\n                const v = maxRgb(data[i], data[i + 1], data[i + 2]);\n                if (v < min) min = v;\n                if (v > max) max = v;\n                cR[v]++;\n              } else {\n                cR[data[i]]++;\n                cG![data[i + 1]]++;\n                cB![data[i + 2]]++;\n              }\n            }\n          } catch (err) {\n            // Skip this tile — window/histogram just lose its samples.\n            console.warn('[viz:window] tile sample failed, skipping', url, err);\n          }\n        }),\n      );\n      // Cache per-channel histograms: grayscale → [intensity]; RGB → [R, G, B].\n      this.sliceHistograms.set(\n        z, gray ? [histogram256(cR)] : [histogram256(cR), histogram256(cG!), histogram256(cB!)],\n      );\n      // Grayscale auto-window — only from full-res samples (coarsest averaging\n      // is inaccurate); the host seeds the channel or re-invalidates.\n      if (gray && fullRes && max > min && (min > 0 || max < 255)) {\n        this.host.onGrayWindowSampled(min, max);\n      }\n    } catch (err) {\n      console.warn('[viz:window] per-image window compute failed — using identity 0..255', err);\n    }\n  }\n\n  /**\n   * Native-bit-depth histogram for >8-bit images, from the server `/histogram`\n   * endpoint (the 8-bit canvas tiles can't carry 16-bit values). Cached per\n   * slice+channel for the session.\n   */\n  native$(infoB64: string, z: number, channel: number, bins: number): Observable<IHistogram | null> {\n    const key = `${z}|${channel}`;\n    const cached = this.nativeHistograms.get(key);\n    if (cached) return of(cached);\n    return from(this.fetchNative(infoB64, z, channel, bins, key));\n  }\n\n  /** Fetch + cache one channel's native histogram from `GET /histogram`. */\n  private async fetchNative(\n    infoB64: string, z: number, channel: number, bins: number, key: string,\n  ): Promise<IHistogram | null> {\n    const url = `${this.api}histogram?info=${infoB64}&channel=${channel}&z=${z}&bins=${bins}&_=${this.histCacheBuster}`;\n    try {\n      // HttpClient calls get auth via the Angular interceptor (unlike OSD's own\n      // ajax tile loader, which needs authHeaders) — mirror the other fetches.\n      const hi = await firstValueFrom(\n        this.http\n          .get<{\n            bitDepth: number; rangeMin: number; rangeMax: number;\n            observedMin: number; observedMax: number; binWidth: number; counts: number[];\n          }>(url)\n          .pipe(timeout(45000)),\n      );\n      if (!hi || !hi.counts) return null;\n      const out: IHistogram = {\n        // Native bin left-edges: rangeMin + i*binWidth.\n        bins: hi.counts.map((_, i) => hi.rangeMin + i * hi.binWidth),\n        counts: hi.counts,\n        max: hi.counts.reduce((m, c) => (c > m ? c : m), 0),\n        bitDepth: hi.bitDepth,\n        rangeMin: hi.rangeMin,\n        rangeMax: hi.rangeMax,\n        observedMin: hi.observedMin,\n        observedMax: hi.observedMax,\n      };\n      this.nativeHistograms.set(key, out);\n      return out;\n    } catch (err) {\n      // 202 (still caching) or a transient error → null; the pane retries.\n      console.warn('[viz:histogram] native histogram fetch failed', err);\n      return null;\n    }\n  }\n}\n"]}