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

package/lib/workers/spatial-math-ops.d.ts

@@ -0,0 +1,65 @@
+import type { SpatialObservations } from '../contracts/spatial-dataset.contract';
+import { DensityGrid, DensityOptions } from '../spatial/spatial-density';
+import { ExpressionField, ExpressionFieldOptions, ExpressionVolumeField, ExpressionVolumeOptions } from '../spatial/spatial-expression';
+import { HeatmapGene, HeatmapGroups, HeatmapMatrix, HeatmapMatrixOptions } from '../spatial/spatial-heatmap';
+/**
+ * The pure spatial field and density math, as messages: what crosses into
+ * `spatial-math.worker` and what comes back, and the one dispatcher both the worker and
+ * the main-thread fallback run. DOM-free and Angular-free, because the worker bundles it.
+ */
+/**
+ * Just the coordinates of {@link SpatialObservations}: all the math reads. Cloning the
+ * full observations would also copy `ids` — millions of strings on a large dataset.
+ */
+export type SpatialMathObservations = Pick<SpatialObservations, 'count' | 'x' | 'y' | 'z'>;
+/** One computation, by name, with the arguments of the synchronous function it runs. */
+export type SpatialMathRequest = {
+    op: 'expressionField';
+    obs: SpatialMathObservations;
+    opts: ExpressionFieldOptions;
+} | {
+    op: 'expressionVolume';
+    obs: SpatialMathObservations;
+    grid: DensityGrid;
+    opts: ExpressionVolumeOptions;
+} | {
+    op: 'rasterizeDensity';
+    obs: SpatialMathObservations;
+    grid: DensityGrid;
+    opts: DensityOptions;
+} | {
+    op: 'heatmapMatrix';
+    genes: readonly HeatmapGene[];
+    groups: HeatmapGroups;
+    opts: HeatmapMatrixOptions;
+};
+/** What each {@link SpatialMathRequest} op resolves to. */
+export interface SpatialMathResults {
+    expressionField: ExpressionField | null;
+    expressionVolume: ExpressionVolumeField | null;
+    rasterizeDensity: Uint8Array | null;
+    heatmapMatrix: HeatmapMatrix | null;
+}
+/** A request on the wire: the computation plus the id its answer is matched by. */
+export type SpatialMathMessage = SpatialMathRequest & {
+    id: number;
+};
+/** The worker's answer to one {@link SpatialMathMessage}. */
+export type SpatialMathReply = {
+    id: number;
+    ok: true;
+    result: SpatialMathResults[keyof SpatialMathResults];
+} | {
+    id: number;
+    ok: false;
+    error: string;
+};
+/** The coordinates of `obs`, without the per-observation strings the math never reads. */
+export declare function slimObservations(obs: SpatialMathObservations): SpatialMathObservations;
+/** Run one request synchronously — in the worker, or on the main thread as the fallback. */
+export declare function runSpatialMath<R extends SpatialMathRequest>(request: R): SpatialMathResults[R['op']];
+/**
+ * The buffers of a result, to transfer rather than copy back: the worker made them and
+ * never reads them again. Deduplicated, since a transfer list may not name one twice.
+ */
+export declare function resultTransferables(result: unknown): ArrayBuffer[];

package/lib/workers/spatial-math-worker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Factory for the spatial-math Web Worker, isolated in its own module so the
+ * `import.meta.url` reference — which the bundler needs in order to locate the worker —
+ * is never pulled into the ts-jest CommonJS compile of anything that uses it. Same
+ * arrangement as `spatial/tsne-worker.ts` and `region-editor/mask-worker.ts`.
+ */
+export declare function createSpatialMathWorker(): Worker;

package/lib/workers/spatial-math.d.ts

@@ -0,0 +1,74 @@
+import type { SpatialObservations } from '../contracts/spatial-dataset.contract';
+import type { DensityGrid, DensityOptions } from '../spatial/spatial-density';
+import type { ExpressionField, ExpressionFieldOptions, ExpressionVolumeField, ExpressionVolumeOptions } from '../spatial/spatial-expression';
+import type { HeatmapGene, HeatmapGroups, HeatmapMatrix, HeatmapMatrixOptions } from '../spatial/spatial-heatmap';
+import { SpatialMathRequest, SpatialMathResults } from './spatial-math-ops';
+/**
+ * Async, off-main-thread versions of the pure spatial field and density math
+ * (`expressionField`, `expressionVolume`, `rasterizeDensity`, `heatmapMatrix`).
+ *
+ * Each call runs in `spatial-math.worker` when it is big enough to be worth posting, and
+ * on the main thread otherwise — below {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS}, where
+ * Web Workers do not exist (jsdom, SSR), or when the worker fails to start. Same
+ * function, same answer either way; only where it runs changes.
+ *
+ * Inputs are copied to the worker, never transferred: they are the dataset's own arrays,
+ * which the caller keeps using. Results are transferred back.
+ *
+ * An `AbortSignal` (a `Supersede` task's, typically) rejects the call with an
+ * `AbortError` as soon as it fires. When that leaves the worker with nothing else to do,
+ * the worker is terminated so the abandoned computation stops using the CPU; the next
+ * call starts a fresh one.
+ */
+/**
+ * Below this many observations (genes × observations for a heatmap) a call runs on the
+ * main thread: copying the inputs to a worker would cost about what it saves.
+ */
+export declare const SPATIAL_MATH_WORKER_MIN_OBSERVATIONS = 50000;
+/** Per-call options of the async spatial math. */
+export interface SpatialMathCallOptions {
+    /** Abandon the call: it rejects with an `AbortError` and its result is dropped. */
+    signal?: AbortSignal;
+    /** Override {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS} for this call (0 forces the worker). */
+    minObservations?: number;
+}
+/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */
+export type SpatialMathWorkerFactory = () => Worker | Promise<Worker>;
+/**
+ * Owns one spatial-math worker and the calls in flight on it. The module-level functions
+ * share one instance; a test, or a caller that wants its own worker, makes another.
+ */
+export declare class SpatialMathClient {
+    private readonly factory?;
+    private worker;
+    private starting;
+    /** Set once the worker failed to start or crashed: every later call runs here. */
+    private unavailable;
+    private nextId;
+    private readonly pending;
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects, so a static import would break every spec that reaches this file.
+     */
+    constructor(factory?: SpatialMathWorkerFactory | undefined);
+    /** Run `request`, in the worker when `size` reaches the threshold and a worker can run. */
+    run<R extends SpatialMathRequest>(request: R, size: number, options?: SpatialMathCallOptions): Promise<SpatialMathResults[R['op']]>;
+    /** Terminate the worker; calls still in flight reject with an `AbortError`. */
+    dispose(): void;
+    private post;
+    private ensureWorker;
+    private startWorker;
+    private onReply;
+    /** The worker died (failed to load, or threw outside a request): answer every call here. */
+    private onCrash;
+    private stopWorker;
+}
+/** {@link expressionField}, off the main thread when it is big enough to matter. */
+export declare function computeExpressionFieldAsync(obs: SpatialObservations, opts: ExpressionFieldOptions, options?: SpatialMathCallOptions): Promise<ExpressionField | null>;
+/** {@link expressionVolume}, off the main thread when it is big enough to matter. */
+export declare function computeExpressionVolumeAsync(obs: SpatialObservations, grid: DensityGrid, opts: ExpressionVolumeOptions, options?: SpatialMathCallOptions): Promise<ExpressionVolumeField | null>;
+/** {@link rasterizeDensity}, off the main thread when it is big enough to matter. */
+export declare function rasterizeDensityAsync(obs: SpatialObservations, grid: DensityGrid, opts: DensityOptions, options?: SpatialMathCallOptions): Promise<Uint8Array | null>;
+/** {@link heatmapMatrix}, off the main thread when it is big enough to matter. */
+export declare function computeHeatmapMatrixAsync(genes: readonly HeatmapGene[], groups: HeatmapGroups, opts?: HeatmapMatrixOptions, options?: SpatialMathCallOptions): Promise<HeatmapMatrix | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jax-data-science/sci-image-visualizer",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -37,10 +37,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@jax-js/jax": "^0.1.24",
     "cellpose-js": "^0.6.0",
     "fast-png": "^6.4.0",
-    "napari-js": "^0.14.0",
+    "napari-js": "^0.18.0",
     "openseadragon": "^6.0.2",
     "plotly.js-dist-min": "^3.0.1",
     "tslib": "^2.3.0"
@@ -55,9 +54,19 @@
     "file-saver": "^2.0.5",
     "image-js": "^0.35.6",
     "onnxruntime-web": "~1.26.0",
+    "primeflex": "^3.3.0 || ^4.0.0",
+    "primeicons": "^7.0.0",
     "primeng": "^17.18.0",
     "rxjs": "^7.8.0"
   },
+  "peerDependenciesMeta": {
+    "primeflex": {
+      "optional": true
+    },
+    "primeicons": {
+      "optional": true
+    }
+  },
   "overrides": {
     "@ngtools/webpack": "17.3.17"
   },

package/src/lib/assets/slice.svg

@@ -0,0 +1,23 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <!-- A volume (a cube) with a slab sliced off it by a scalpel: the slice editor. -->
+  <defs>
+    <mask id="slice-cut" maskUnits="userSpaceOnUse" x="-64" y="-64" width="192" height="192">
+      <rect x="-64" y="-64" width="192" height="192" fill="#fff"/>
+      <!-- The cube's lines stop short of the scalpel, so it reads at toolbar size. -->
+      <path d="M27.4 19.4 Q20.5 29.3 24.9 42.6 L34.1 21.4 Z" fill="#000" stroke="#000" stroke-width="5" stroke-linejoin="round"/>
+      <path d="M31.8 19.1 L34.2 11.0 M31.4 20.6 L31.8 19.1" stroke="#000" stroke-width="12" stroke-linecap="round"/>
+    </mask>
+  </defs>
+  <g transform="translate(4.89 -8.48) scale(1.1566)">
+  <g fill="none" stroke="#000" stroke-width="4.6" stroke-linejoin="round" stroke-linecap="round" mask="url(#slice-cut)">
+    <path d="M22.0 59.0 L30.3 54.2 L30.3 35.7 L14.3 26.4 L6.0 31.2 L6.0 49.8 Z M22.0 40.5 L22.0 59.0 M22.0 40.5 L30.3 35.7 M22.0 40.5 L6.0 31.2"/>
+    <path d="M35.5 51.2 L40.9 48.1 L40.9 29.6 L24.9 20.3 L19.4 23.5 L19.4 42.0 Z M35.5 32.7 L35.5 51.2 M35.5 32.7 L40.9 29.6 M35.5 32.7 L19.4 23.5"/>
+    <!-- The slab's cut face: the section the slice shows. -->
+    <path d="M35.5 51.2 L35.5 32.7 L19.4 23.5 L19.4 42.0 Z" fill="#000"/>
+  </g>
+  <path d="M27.4 19.4 Q20.5 29.3 24.9 42.6 L34.1 21.4 Z" fill="#000"/>
+  <path d="M31.8 19.1 L34.2 11.0" stroke="#000" stroke-width="7.5" stroke-linecap="round"/>
+  <path d="M31.4 20.6 L31.8 19.1" stroke="#000" stroke-width="3.5" stroke-linecap="round"/>
+  </g>
+</svg>
+

package/src/lib/styles/_viz-icons-rules.scss

@@ -0,0 +1,73 @@
+@use 'sass:list';
+
+// The visualizer's toolbar / context-menu icon classes, as a mixin so the same rules can
+// be emitted from two places with the right asset path for each:
+//  - `viz-icons.scss`, the stylesheet the package ships for hosts (global styles);
+//  - the visualizer component, inside `::ng-deep`, so nothing changes for a host that
+//    does not include the shipped stylesheet.
+// They must be global either way: the context menu and the toolbar overlays are appended
+// to <body>, outside the component's view.
+
+$icons: (
+  'zoom-box-off-icon': 'zoom-box',
+  'wand-icon': 'wand',
+  'brush-icon': 'paintbrush',
+  'polyline-icon': 'polyline',
+  'polygon-vertices-icon': 'polygon-vertices',
+  'vertex-add-icon': 'vertex-add',
+  'vertex-delete-icon': 'vertex-delete',
+  'region-move-icon': 'region-move',
+  'to-bezier-icon': 'to-bezier',
+  'to-polygon-icon': 'to-polygon',
+);
+
+// Icons inverted to white on the highlighted (active) context-menu entry.
+$context-menu-icons: (
+  'zoom-box-off-icon',
+  'wand-icon',
+  'polyline-icon',
+  'polygon-vertices-icon',
+  'vertex-add-icon',
+  'vertex-delete-icon',
+  'region-move-icon',
+  'to-bezier-icon',
+  'to-polygon-icon'
+);
+
+/// Emit the icon and active-context-menu rules. `$assets` is the path, relative to the
+/// stylesheet being compiled, of the package's `src/lib/assets` folder.
+@mixin rules($assets) {
+  .context-menu-active > .p-menuitem-content {
+    background-color: var(--primary-color) !important;
+  }
+
+  .context-menu-active > .p-menuitem-content .p-menuitem-icon,
+  .context-menu-active > .p-menuitem-content .p-menuitem-text {
+    color: #ffffff !important;
+  }
+
+  $active: ();
+  @each $class in $context-menu-icons {
+    $active: list.append($active, '.context-menu-active > .p-menuitem-content .#{$class}', $separator: comma);
+  }
+  #{$active} {
+    filter: brightness(0) invert(1);
+  }
+
+  @each $class, $file in $icons {
+    .#{$class} {
+      background: url('#{$assets}/#{$file}.svg') no-repeat center center;
+      background-size: contain;
+      width: 1.25rem;
+      height: 1.25rem;
+      display: inline-block;
+      filter: brightness(0)
+        invert(47%)
+        sepia(98%)
+        saturate(567%)
+        hue-rotate(181deg)
+        brightness(103%)
+        contrast(98%);
+    }
+  }
+}

package/src/lib/styles/viz-icons.scss

@@ -0,0 +1,14 @@
+// Global icon rules of the visualizer's toolbar and context menu, shipped for hosts.
+//
+// The visualizer component also emits these when it loads, so including this file is
+// optional. Include it to have the classes defined before any visualizer has loaded (a
+// host toolbar or menu that reuses them), and independent of stylesheet load order. In
+// angular.json:
+//
+//   "styles": ["node_modules/@jax-data-science/sci-image-visualizer/src/lib/styles/viz-icons.scss"]
+//
+// The icon URLs are relative to this file (`../assets/*.svg`, the package's assets folder),
+// which the Angular CLI resolves and bundles.
+@use 'viz-icons-rules';
+
+@include viz-icons-rules.rules('../assets');

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

@@ -1,97 +0,0 @@
-/**
- * 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.
- */
-/**
- * Re-exported from napari-js, which owns the projection now.
- *
- * This used to be a local copy: the same column-major multiply, perspective divide and y-flip
- * that {@link NapariVisualizerService.getSpatialScreenProjection} ALSO carried, written twice
- * with two different behind-the-eye conventions. The renderer owns the camera and the clip
- * convention, so it owns the projection; kept as a named export here only so the overlays that
- * import it from this module do not all have to change.
- */
-import { projectPoint } from 'napari-js';
-export { projectPoint };
-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 * Re-exported from napari-js, which owns the projection now.\n *\n * This used to be a local copy: the same column-major multiply, perspective divide and y-flip\n * that {@link NapariVisualizerService.getSpatialScreenProjection} ALSO carried, written twice\n * with two different behind-the-eye conventions. The renderer owns the camera and the clip\n * convention, so it owns the projection; kept as a named export here only so the overlays that\n * import it from this module do not all have to change.\n */\nimport { projectPoint } from 'napari-js';\n\nexport { projectPoint };\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"]}