@jax-data-science/sci-image-visualizer 0.6.0 → 0.8.0

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

@@ -0,0 +1,195 @@
+/**
+ * Overview navigator (minimap) for the napari-js 2D views, mirroring the OSD backend's
+ * built-in navigator: a thumbnail of the whole image in the bottom-right corner with the
+ * current viewport drawn on it. Clicking re-centres the main view on that point at the
+ * same zoom; dragging pans continuously — exactly OSD's behaviour.
+ *
+ * napari keeps layers at full-resolution pixel scale, so the camera's world units ARE
+ * image pixels and the thumbnail maps onto `[0, width) × [0, height)` directly.
+ */
+/** Fraction of the host's width the navigator takes — OSD's `navigatorSizeRatio`. */
+export const NAVIGATOR_SIZE_RATIO = 0.16;
+const NAVIGATOR_MIN_PX = 110;
+const NAVIGATOR_MAX_PX = 300;
+/** Box size and scale for a `worldW × worldH` image in a host `hostW` wide. */
+export function navigatorLayout(hostW, worldW, worldH, ratio = NAVIGATOR_SIZE_RATIO) {
+    if (!(worldW > 0) || !(worldH > 0) || !(hostW > 0))
+        return null;
+    const longest = Math.min(NAVIGATOR_MAX_PX, Math.max(NAVIGATOR_MIN_PX, hostW * ratio));
+    const scale = longest / Math.max(worldW, worldH);
+    return { width: worldW * scale, height: worldH * scale, scale };
+}
+/** The part of the world the camera shows, as `[x0, y0, x1, y1]`. */
+export function viewportWorldRect(center, zoom, hostW, hostH) {
+    const hw = hostW / zoom / 2;
+    const hh = hostH / zoom / 2;
+    return [center[0] - hw, center[1] - hh, center[0] + hw, center[1] + hh];
+}
+/** A point in the navigator box → world coordinates, clamped to the image. */
+export function navigatorToWorld(px, py, layout, worldW, worldH) {
+    const x = Math.min(worldW, Math.max(0, px / layout.scale));
+    const y = Math.min(worldH, Math.max(0, py / layout.scale));
+    return [x, y];
+}
+export class NapariNavigator {
+    constructor(host, camera, worldW, worldH, 
+    /** Called when the pointer enters the navigator — e.g. to hide a hover tooltip that
+     *  was describing the canvas underneath. */
+    onEnter) {
+        this.host = host;
+        this.camera = camera;
+        this.worldW = worldW;
+        this.worldH = worldH;
+        this.onEnter = onEnter;
+        /** Aborted by destroy() to remove every DOM listener the box holds. */
+        this.listeners = new AbortController();
+        this.layout = null;
+        this.image = null;
+        this.dragging = false;
+        this.visible = true;
+        this.onDown = (e) => {
+            stop(e);
+            if (e.button !== 0)
+                return;
+            this.dragging = true;
+            this.box.setPointerCapture?.(e.pointerId);
+            this.panTo(e);
+        };
+        this.onMove = (e) => {
+            // Always consumed: a hover over the navigator is not a hover over the canvas.
+            stop(e);
+            if (this.dragging)
+                this.panTo(e);
+        };
+        this.onUp = (e) => {
+            if (!this.dragging)
+                return;
+            stop(e);
+            this.dragging = false;
+            this.box.releasePointerCapture?.(e.pointerId);
+        };
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        this.box = document.createElement('div');
+        this.box.className = 'napari-navigator';
+        Object.assign(this.box.style, {
+            position: 'absolute',
+            right: '12px',
+            bottom: '12px',
+            background: 'rgba(0,0,0,0.5)',
+            border: '1px solid rgba(255,255,255,0.35)',
+            overflow: 'hidden',
+            cursor: 'pointer',
+            zIndex: '5',
+            touchAction: 'none',
+        });
+        this.canvas = document.createElement('canvas');
+        Object.assign(this.canvas.style, { display: 'block', width: '100%', height: '100%' });
+        // OSD's default display-region style.
+        this.region = document.createElement('div');
+        Object.assign(this.region.style, {
+            position: 'absolute',
+            border: '2px solid #900',
+            boxSizing: 'border-box',
+            pointerEvents: 'none',
+        });
+        this.box.append(this.canvas, this.region);
+        host.appendChild(this.box);
+        // The navigator's own gestures must not also reach the canvas underneath (pan/zoom,
+        // region drawing), so every pointer/wheel event is consumed here.
+        // One signal for all of them, so destroy() releases every listener at once.
+        const signal = this.listeners.signal;
+        this.box.addEventListener('pointerdown', this.onDown, { signal });
+        this.box.addEventListener('pointermove', this.onMove, { signal });
+        this.box.addEventListener('pointerup', this.onUp, { signal });
+        this.box.addEventListener('pointercancel', this.onUp, { signal });
+        this.box.addEventListener('pointerenter', () => this.onEnter?.(), { signal });
+        for (const type of ['wheel', 'click', 'dblclick', 'contextmenu', 'mousedown']) {
+            this.box.addEventListener(type, stop, { passive: false, signal });
+        }
+        this.disconnectCamera = camera.changed.connect(() => this.updateRegion());
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(() => this.relayout());
+            this.resizeObserver.observe(host);
+        }
+        this.relayout();
+    }
+    /** The thumbnail to draw: any image of the whole world (a coarse pyramid level). */
+    setImage(image) {
+        this.image = image;
+        this.drawImage();
+    }
+    /** The image's world size changed (another image was loaded). */
+    setWorld(width, height) {
+        this.worldW = width;
+        this.worldH = height;
+        this.relayout();
+    }
+    setVisible(visible) {
+        this.visible = visible;
+        this.box.style.display = visible && this.layout ? 'block' : 'none';
+    }
+    destroy() {
+        this.listeners.abort();
+        this.disconnectCamera();
+        this.resizeObserver?.disconnect();
+        this.box.remove();
+    }
+    relayout() {
+        this.layout = navigatorLayout(this.host.clientWidth, this.worldW, this.worldH);
+        if (!this.layout) {
+            this.box.style.display = 'none';
+            return;
+        }
+        this.box.style.display = this.visible ? 'block' : 'none';
+        this.box.style.width = `${this.layout.width}px`;
+        this.box.style.height = `${this.layout.height}px`;
+        const dpr = typeof devicePixelRatio === 'number' ? devicePixelRatio : 1;
+        this.canvas.width = Math.max(1, Math.round(this.layout.width * dpr));
+        this.canvas.height = Math.max(1, Math.round(this.layout.height * dpr));
+        this.drawImage();
+        this.updateRegion();
+    }
+    drawImage() {
+        const ctx = this.canvas.getContext('2d');
+        if (!ctx)
+            return;
+        ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+        if (this.image) {
+            ctx.imageSmoothingEnabled = true;
+            ctx.drawImage(this.image, 0, 0, this.canvas.width, this.canvas.height);
+        }
+    }
+    /** Draw the viewport rectangle, clipped to the box (as OSD does when zoomed out). */
+    updateRegion() {
+        const l = this.layout;
+        if (!l)
+            return;
+        const [x0, y0, x1, y1] = viewportWorldRect(this.camera.center, this.camera.zoom, this.host.clientWidth, this.host.clientHeight);
+        const left = Math.max(0, x0 * l.scale);
+        const top = Math.max(0, y0 * l.scale);
+        const right = Math.min(l.width, x1 * l.scale);
+        const bottom = Math.min(l.height, y1 * l.scale);
+        Object.assign(this.region.style, {
+            left: `${left}px`,
+            top: `${top}px`,
+            width: `${Math.max(2, right - left)}px`,
+            height: `${Math.max(2, bottom - top)}px`,
+            display: right > left && bottom > top ? 'block' : 'none',
+        });
+    }
+    /** Re-centre the main view on the navigator point under the pointer, keeping the zoom. */
+    panTo(e) {
+        const l = this.layout;
+        if (!l)
+            return;
+        const rect = this.box.getBoundingClientRect();
+        this.camera.center = navigatorToWorld(e.clientX - rect.left, e.clientY - rect.top, l, this.worldW, this.worldH);
+    }
+}
+function stop(e) {
+    e.stopPropagation();
+    if (e.cancelable)
+        e.preventDefault();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-navigator.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-navigator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Overview navigator (minimap) for the napari-js 2D views, mirroring the OSD backend's\n * built-in navigator: a thumbnail of the whole image in the bottom-right corner with the\n * current viewport drawn on it. Clicking re-centres the main view on that point at the\n * same zoom; dragging pans continuously — exactly OSD's behaviour.\n *\n * napari keeps layers at full-resolution pixel scale, so the camera's world units ARE\n * image pixels and the thumbnail maps onto `[0, width) × [0, height)` directly.\n */\n\n/** The slice of the napari 2D camera the navigator reads and drives. */\nexport interface NavigatorCamera {\n  center: readonly [number, number];\n  readonly zoom: number;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\n/** Where the thumbnail sits inside the navigator box, in CSS px. */\nexport interface NavigatorLayout {\n  /** Box size. */\n  width: number;\n  height: number;\n  /** CSS px per world unit (image pixel). */\n  scale: number;\n}\n\n/** Fraction of the host's width the navigator takes — OSD's `navigatorSizeRatio`. */\nexport const NAVIGATOR_SIZE_RATIO = 0.16;\nconst NAVIGATOR_MIN_PX = 110;\nconst NAVIGATOR_MAX_PX = 300;\n\n/** Box size and scale for a `worldW × worldH` image in a host `hostW` wide. */\nexport function navigatorLayout(\n  hostW: number, worldW: number, worldH: number, ratio = NAVIGATOR_SIZE_RATIO,\n): NavigatorLayout | null {\n  if (!(worldW > 0) || !(worldH > 0) || !(hostW > 0)) return null;\n  const longest = Math.min(NAVIGATOR_MAX_PX, Math.max(NAVIGATOR_MIN_PX, hostW * ratio));\n  const scale = longest / Math.max(worldW, worldH);\n  return { width: worldW * scale, height: worldH * scale, scale };\n}\n\n/** The part of the world the camera shows, as `[x0, y0, x1, y1]`. */\nexport function viewportWorldRect(\n  center: readonly [number, number], zoom: number, hostW: number, hostH: number,\n): [number, number, number, number] {\n  const hw = hostW / zoom / 2;\n  const hh = hostH / zoom / 2;\n  return [center[0] - hw, center[1] - hh, center[0] + hw, center[1] + hh];\n}\n\n/** A point in the navigator box → world coordinates, clamped to the image. */\nexport function navigatorToWorld(\n  px: number, py: number, layout: NavigatorLayout, worldW: number, worldH: number,\n): [number, number] {\n  const x = Math.min(worldW, Math.max(0, px / layout.scale));\n  const y = Math.min(worldH, Math.max(0, py / layout.scale));\n  return [x, y];\n}\n\nexport class NapariNavigator {\n  private readonly box: HTMLDivElement;\n  private readonly canvas: HTMLCanvasElement;\n  private readonly region: HTMLDivElement;\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  /** Aborted by destroy() to remove every DOM listener the box holds. */\n  private readonly listeners = new AbortController();\n  private layout: NavigatorLayout | null = null;\n  private image: CanvasImageSource | null = null;\n  private dragging = false;\n  private visible = true;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera: NavigatorCamera,\n    private worldW: number,\n    private worldH: number,\n    /** Called when the pointer enters the navigator — e.g. to hide a hover tooltip that\n     *  was describing the canvas underneath. */\n    private readonly onEnter?: () => void,\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n\n    this.box = document.createElement('div');\n    this.box.className = 'napari-navigator';\n    Object.assign(this.box.style, {\n      position: 'absolute',\n      right: '12px',\n      bottom: '12px',\n      background: 'rgba(0,0,0,0.5)',\n      border: '1px solid rgba(255,255,255,0.35)',\n      overflow: 'hidden',\n      cursor: 'pointer',\n      zIndex: '5',\n      touchAction: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n\n    this.canvas = document.createElement('canvas');\n    Object.assign(this.canvas.style, { display: 'block', width: '100%', height: '100%' });\n\n    // OSD's default display-region style.\n    this.region = document.createElement('div');\n    Object.assign(this.region.style, {\n      position: 'absolute',\n      border: '2px solid #900',\n      boxSizing: 'border-box',\n      pointerEvents: 'none',\n    } satisfies Partial<CSSStyleDeclaration>);\n\n    this.box.append(this.canvas, this.region);\n    host.appendChild(this.box);\n\n    // The navigator's own gestures must not also reach the canvas underneath (pan/zoom,\n    // region drawing), so every pointer/wheel event is consumed here.\n    // One signal for all of them, so destroy() releases every listener at once.\n    const signal = this.listeners.signal;\n    this.box.addEventListener('pointerdown', this.onDown, { signal });\n    this.box.addEventListener('pointermove', this.onMove, { signal });\n    this.box.addEventListener('pointerup', this.onUp, { signal });\n    this.box.addEventListener('pointercancel', this.onUp, { signal });\n    this.box.addEventListener('pointerenter', () => this.onEnter?.(), { signal });\n    for (const type of ['wheel', 'click', 'dblclick', 'contextmenu', 'mousedown'] as const) {\n      this.box.addEventListener(type, stop, { passive: false, signal });\n    }\n\n    this.disconnectCamera = camera.changed.connect(() => this.updateRegion());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.relayout());\n      this.resizeObserver.observe(host);\n    }\n    this.relayout();\n  }\n\n  /** The thumbnail to draw: any image of the whole world (a coarse pyramid level). */\n  setImage(image: CanvasImageSource | null): void {\n    this.image = image;\n    this.drawImage();\n  }\n\n  /** The image's world size changed (another image was loaded). */\n  setWorld(width: number, height: number): void {\n    this.worldW = width;\n    this.worldH = height;\n    this.relayout();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.box.style.display = visible && this.layout ? 'block' : 'none';\n  }\n\n  destroy(): void {\n    this.listeners.abort();\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    this.box.remove();\n  }\n\n  private relayout(): void {\n    this.layout = navigatorLayout(this.host.clientWidth, this.worldW, this.worldH);\n    if (!this.layout) {\n      this.box.style.display = 'none';\n      return;\n    }\n    this.box.style.display = this.visible ? 'block' : 'none';\n    this.box.style.width = `${this.layout.width}px`;\n    this.box.style.height = `${this.layout.height}px`;\n    const dpr = typeof devicePixelRatio === 'number' ? devicePixelRatio : 1;\n    this.canvas.width = Math.max(1, Math.round(this.layout.width * dpr));\n    this.canvas.height = Math.max(1, Math.round(this.layout.height * dpr));\n    this.drawImage();\n    this.updateRegion();\n  }\n\n  private drawImage(): void {\n    const ctx = this.canvas.getContext('2d');\n    if (!ctx) return;\n    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);\n    if (this.image) {\n      ctx.imageSmoothingEnabled = true;\n      ctx.drawImage(this.image, 0, 0, this.canvas.width, this.canvas.height);\n    }\n  }\n\n  /** Draw the viewport rectangle, clipped to the box (as OSD does when zoomed out). */\n  private updateRegion(): void {\n    const l = this.layout;\n    if (!l) return;\n    const [x0, y0, x1, y1] = viewportWorldRect(\n      this.camera.center, this.camera.zoom, this.host.clientWidth, this.host.clientHeight,\n    );\n    const left = Math.max(0, x0 * l.scale);\n    const top = Math.max(0, y0 * l.scale);\n    const right = Math.min(l.width, x1 * l.scale);\n    const bottom = Math.min(l.height, y1 * l.scale);\n    Object.assign(this.region.style, {\n      left: `${left}px`,\n      top: `${top}px`,\n      width: `${Math.max(2, right - left)}px`,\n      height: `${Math.max(2, bottom - top)}px`,\n      display: right > left && bottom > top ? 'block' : 'none',\n    });\n  }\n\n  /** Re-centre the main view on the navigator point under the pointer, keeping the zoom. */\n  private panTo(e: PointerEvent): void {\n    const l = this.layout;\n    if (!l) return;\n    const rect = this.box.getBoundingClientRect();\n    this.camera.center = navigatorToWorld(\n      e.clientX - rect.left, e.clientY - rect.top, l, this.worldW, this.worldH,\n    );\n  }\n\n  private readonly onDown = (e: PointerEvent): void => {\n    stop(e);\n    if (e.button !== 0) return;\n    this.dragging = true;\n    this.box.setPointerCapture?.(e.pointerId);\n    this.panTo(e);\n  };\n\n  private readonly onMove = (e: PointerEvent): void => {\n    // Always consumed: a hover over the navigator is not a hover over the canvas.\n    stop(e);\n    if (this.dragging) this.panTo(e);\n  };\n\n  private readonly onUp = (e: PointerEvent): void => {\n    if (!this.dragging) return;\n    stop(e);\n    this.dragging = false;\n    this.box.releasePointerCapture?.(e.pointerId);\n  };\n}\n\nfunction stop(e: Event): void {\n  e.stopPropagation();\n  if (e.cancelable) e.preventDefault();\n}\n"]}