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

package/esm2022/lib/implementations/napari-js/napari-axes-labels.mjs

@@ -0,0 +1,106 @@
+/**
+ * DOM text labels for the napari-js 3D axes gizmo (jit-ui#102). The {@link AxesLayer} draws the
+ * axis lines/ticks/box in WebGPU; this overlay adds the crisp X/Y/Z + scale text on top, projected
+ * with the 3D camera's view-projection so each label tracks its anchor as the volume orbits.
+ * Mirrors the {@link NapariScaleBar} overlay pattern (absolute-positioned over the host, updated on
+ * every `camera3d.changed`). Falls back to pixel/slice counts when no physical µm/pixel is known.
+ */
+/**
+ * Project a world point through a column-major 4×4 MVP to CSS-pixel screen coordinates.
+ * Returns `visible: false` when the point is at/behind the camera (w ≤ 0). Pure — unit-tested.
+ */
+export function projectPoint(mvp, p, vw, vh) {
+    const [x, y, z] = p;
+    // Column-major: clip[r] = Σ_c M[c*4+r] * v[c].
+    const cx = mvp[0] * x + mvp[4] * y + mvp[8] * z + mvp[12];
+    const cy = mvp[1] * x + mvp[5] * y + mvp[9] * z + mvp[13];
+    const cw = mvp[3] * x + mvp[7] * y + mvp[11] * z + mvp[15];
+    if (cw <= 0)
+        return { x: 0, y: 0, visible: false };
+    const ndcX = cx / cw;
+    const ndcY = cy / cw;
+    return {
+        x: (ndcX * 0.5 + 0.5) * vw,
+        y: (0.5 - ndcY * 0.5) * vh,
+        visible: true,
+    };
+}
+export class NapariAxesLabels {
+    constructor(host, camera3d, labels) {
+        this.host = host;
+        this.camera3d = camera3d;
+        this.labels = labels;
+        this.els = [];
+        this.visible = true;
+        if (getComputedStyle(host).position === 'static')
+            host.style.position = 'relative';
+        for (const spec of labels) {
+            const el = document.createElement('span');
+            Object.assign(el.style, {
+                position: 'absolute',
+                zIndex: '30',
+                pointerEvents: 'none',
+                font: '11px sans-serif',
+                fontWeight: '600',
+                color: spec.color,
+                textShadow: '0 0 3px #000, 0 0 3px #000',
+                whiteSpace: 'nowrap',
+                transform: 'translate(-50%, -50%)',
+                userSelect: 'none',
+            });
+            el.textContent = spec.text;
+            this.host.appendChild(el);
+            this.els.push(el);
+        }
+        this.disconnectCamera = this.camera3d.changed.connect(() => this.update());
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(() => this.update());
+            this.resizeObserver.observe(this.host);
+        }
+        this.update();
+    }
+    setVisible(visible) {
+        this.visible = visible;
+        this.update();
+    }
+    /** Replace the label anchors/text in place (same count) and reproject — lets a host move the
+     *  labels when the box geometry changes live (e.g. a Z-height gizmo restretching the volume)
+     *  without tearing down and recreating the DOM elements (which would flicker). */
+    updateAnchors(labels) {
+        for (let i = 0; i < this.labels.length && i < labels.length; i++) {
+            this.labels[i] = labels[i];
+            if (labels[i].text !== this.els[i].textContent)
+                this.els[i].textContent = labels[i].text;
+        }
+        this.update();
+    }
+    update() {
+        const vw = this.host.clientWidth;
+        const vh = this.host.clientHeight;
+        if (!this.visible || vw <= 0 || vh <= 0) {
+            for (const el of this.els)
+                el.style.display = 'none';
+            return;
+        }
+        const mvp = this.camera3d.viewProjection(vw, vh);
+        this.labels.forEach((spec, i) => {
+            const el = this.els[i];
+            const s = projectPoint(mvp, spec.anchor, vw, vh);
+            if (!s.visible) {
+                el.style.display = 'none';
+                return;
+            }
+            el.style.display = '';
+            el.style.left = `${s.x}px`;
+            el.style.top = `${s.y}px`;
+        });
+    }
+    destroy() {
+        this.disconnectCamera();
+        this.resizeObserver?.disconnect();
+        for (const el of this.els)
+            el.parentNode?.removeChild(el);
+        this.els.length = 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-axes-labels.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-axes-labels.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DOM text labels for the napari-js 3D axes gizmo (jit-ui#102). The {@link AxesLayer} draws the\n * axis lines/ticks/box in WebGPU; this overlay adds the crisp X/Y/Z + scale text on top, projected\n * with the 3D camera's view-projection so each label tracks its anchor as the volume orbits.\n * Mirrors the {@link NapariScaleBar} overlay pattern (absolute-positioned over the host, updated on\n * every `camera3d.changed`). Falls back to pixel/slice counts when no physical µm/pixel is known.\n */\n\n/** One axis label: a world-space anchor (the axis end, in the volume's centred box), the text to\n *  show, and its colour (matching the WebGPU axis colour). */\nexport interface AxisLabelSpec {\n  anchor: [number, number, number];\n  text: string;\n  color: string;\n}\n\n/** The slice of napari's Camera3D this overlay reads. `viewProjection` is column-major (gl-matrix). */\nexport interface AxesLabelCamera3D {\n  viewProjection(vw: number, vh: number): ArrayLike<number>;\n  readonly changed: { connect(listener: () => void): () => void };\n}\n\n/**\n * Project a world point through a column-major 4×4 MVP to CSS-pixel screen coordinates.\n * Returns `visible: false` when the point is at/behind the camera (w ≤ 0). Pure — unit-tested.\n */\nexport function projectPoint(\n  mvp: ArrayLike<number>,\n  p: [number, number, number],\n  vw: number,\n  vh: number,\n): { x: number; y: number; visible: boolean } {\n  const [x, y, z] = p;\n  // Column-major: clip[r] = Σ_c M[c*4+r] * v[c].\n  const cx = mvp[0] * x + mvp[4] * y + mvp[8] * z + mvp[12];\n  const cy = mvp[1] * x + mvp[5] * y + mvp[9] * z + mvp[13];\n  const cw = mvp[3] * x + mvp[7] * y + mvp[11] * z + mvp[15];\n  if (cw <= 0) return { x: 0, y: 0, visible: false };\n  const ndcX = cx / cw;\n  const ndcY = cy / cw;\n  return {\n    x: (ndcX * 0.5 + 0.5) * vw,\n    y: (0.5 - ndcY * 0.5) * vh,\n    visible: true,\n  };\n}\n\nexport class NapariAxesLabels {\n  private readonly els: HTMLSpanElement[] = [];\n  private readonly disconnectCamera: () => void;\n  private readonly resizeObserver?: ResizeObserver;\n  private visible = true;\n\n  constructor(\n    private readonly host: HTMLElement,\n    private readonly camera3d: AxesLabelCamera3D,\n    private readonly labels: AxisLabelSpec[],\n  ) {\n    if (getComputedStyle(host).position === 'static') host.style.position = 'relative';\n    for (const spec of labels) {\n      const el = document.createElement('span');\n      Object.assign(el.style, {\n        position: 'absolute',\n        zIndex: '30',\n        pointerEvents: 'none',\n        font: '11px sans-serif',\n        fontWeight: '600',\n        color: spec.color,\n        textShadow: '0 0 3px #000, 0 0 3px #000',\n        whiteSpace: 'nowrap',\n        transform: 'translate(-50%, -50%)',\n        userSelect: 'none',\n      } as Partial<CSSStyleDeclaration>);\n      el.textContent = spec.text;\n      this.host.appendChild(el);\n      this.els.push(el);\n    }\n    this.disconnectCamera = this.camera3d.changed.connect(() => this.update());\n    if (typeof ResizeObserver !== 'undefined') {\n      this.resizeObserver = new ResizeObserver(() => this.update());\n      this.resizeObserver.observe(this.host);\n    }\n    this.update();\n  }\n\n  setVisible(visible: boolean): void {\n    this.visible = visible;\n    this.update();\n  }\n\n  /** Replace the label anchors/text in place (same count) and reproject — lets a host move the\n   *  labels when the box geometry changes live (e.g. a Z-height gizmo restretching the volume)\n   *  without tearing down and recreating the DOM elements (which would flicker). */\n  updateAnchors(labels: AxisLabelSpec[]): void {\n    for (let i = 0; i < this.labels.length && i < labels.length; i++) {\n      this.labels[i] = labels[i];\n      if (labels[i].text !== this.els[i].textContent) this.els[i].textContent = labels[i].text;\n    }\n    this.update();\n  }\n\n  private update(): void {\n    const vw = this.host.clientWidth;\n    const vh = this.host.clientHeight;\n    if (!this.visible || vw <= 0 || vh <= 0) {\n      for (const el of this.els) el.style.display = 'none';\n      return;\n    }\n    const mvp = this.camera3d.viewProjection(vw, vh);\n    this.labels.forEach((spec, i) => {\n      const el = this.els[i];\n      const s = projectPoint(mvp, spec.anchor, vw, vh);\n      if (!s.visible) {\n        el.style.display = 'none';\n        return;\n      }\n      el.style.display = '';\n      el.style.left = `${s.x}px`;\n      el.style.top = `${s.y}px`;\n    });\n  }\n\n  destroy(): void {\n    this.disconnectCamera();\n    this.resizeObserver?.disconnect();\n    for (const el of this.els) el.parentNode?.removeChild(el);\n    this.els.length = 0;\n  }\n}\n"]}