@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

package/esm2022/lib/implementations/napari-js/napari-spatial-scene.mjs

@@ -0,0 +1,159 @@
+import { combineLatest, of } from 'rxjs';
+import { emptySelection } from '../../spatial/spatial-selection';
+import { Supersede } from '../../util/supersede';
+import { ContrastWindowCache } from './napari-spatial-encoding';
+import { SpatialHover } from './napari-spatial-hover';
+import { NapariSpatialTileLayers } from './napari-spatial-tiles';
+/**
+ * The spatial state that outlives a scene (review Appendix B): what the subscription last saw, the
+ * memoised percentile windows, the selection revision counter and the estimated gene-map FIELDS —
+ * viewer-independent and expensive, so a re-plot recolours the cached field instead of estimating
+ * it again. Everything that names a layer of a viewer belongs to the scene instead.
+ */
+export class SpatialSession {
+    constructor(port, selection, sinks) {
+        this.port = port;
+        this.selection = selection;
+        this.sinks = sinks;
+        /** Latest (dataset, view, selection) the spatial subscription saw — so a slice change can
+         *  rebuild the markers for the new plane, and the tile layers and the hover can read it. */
+        this.latest = null;
+        /** Spatial colouring's percentile windows, memoised per coloured vector (SPATIAL-12). */
+        this.contrastWindows = new ContrastWindowCache();
+        /** The 2D gene map's field (the expensive half: it survives a recolour and a re-plot). */
+        this.geneMap = { key: null, field: null };
+        /** The 3D gene map's field. */
+        this.geneMapVolume = { key: null, field: null };
+        this.lastSelectionSeen = null;
+        this.selectionRevision = 0;
+        /** Level-of-detail cell outlines, transcripts and density over the 2D view — created on first
+         *  use, only when a spatial port is bound, and kept across scenes (its tile caches with it). */
+        this.tileLayers = null;
+        this.tileOwner = null;
+    }
+    /** The tile layers, if they were ever built. */
+    get tiles() {
+        return this.tileLayers;
+    }
+    /**
+     * The tile layers, built on first use (null without a spatial port), now drawing for `owner`.
+     * Their host callbacks read the session's live state and the owner's canvas, so they never hold
+     * a stale dataset or colormap.
+     */
+    claimTiles(owner) {
+        const port = this.port;
+        if (!port)
+            return null;
+        this.tileOwner = owner;
+        const sinks = this.sinks;
+        this.tileLayers ??= new NapariSpatialTileLayers(port, {
+            latest: () => this.latest,
+            canvasSize: () => this.tileOwner?.canvasSize() ?? [0, 0],
+            continuousLut: (view) => sinks.continuousLut(view),
+            estimateChanged: (e) => sinks.estimateChanged(e),
+            geneCountsChanged: (c) => sinks.geneCountsChanged(c),
+            loadingChanged: (layers) => sinks.loadingChanged(layers),
+            densityChanged: (d) => sinks.densityChanged(d),
+            polygonsShownChanged: () => this.tileOwner?.polygonsShownChanged(),
+        });
+        return this.tileLayers;
+    }
+    /** `owner`'s scene is going away: take the tile layers off its viewer. */
+    releaseTiles(owner) {
+        if (this.tileOwner !== owner)
+            return;
+        this.tileOwner = null;
+        this.tileLayers?.detach();
+    }
+    /**
+     * A revision number for a selection object.
+     *
+     * The store hands out a NEW mask object per change, so object identity is the
+     * cheap and exact way to tell two selections apart — a fingerprint over 3.7M
+     * mask bytes would be neither. Counting revisions keeps the cache key a short
+     * string.
+     */
+    selectionRev(selection) {
+        if (selection !== this.lastSelectionSeen) {
+            this.lastSelectionSeen = selection;
+            this.selectionRevision++;
+        }
+        return this.selectionRevision;
+    }
+    /**
+     * Everything a spatial scene redraws on: the dataset, the view state, the selection — and the
+     * display colormap and reverse flag, which are inputs here, not just something read at build
+     * time: `continuousColormap: null` means "follow the image's colormap", and a setting that only
+     * takes effect at the next unrelated rebuild is not one. Null without a spatial port.
+     */
+    changes$(store) {
+        const port = this.port;
+        if (!port)
+            return null;
+        const selection$ = this.selection?.getSelection$() ?? of(emptySelection());
+        return combineLatest([
+            port.getDataset$(),
+            store.getSpatialView$(),
+            selection$,
+            store.getColormap(),
+            store.getReverseScale(),
+        ]);
+    }
+}
+/**
+ * What the 2D and 3D spatial scenes share: the subscription that redraws them, the hover over
+ * them, and the latest-wins sequencing of their (async) rebuilds.
+ */
+export class SpatialSceneBase {
+    constructor(ctx, session, is3d) {
+        this.ctx = ctx;
+        this.session = session;
+        /** Latest wins within the scene: a colour fetch is a round-trip, so a fast sequence of
+         *  colour-by changes can resolve out of order, and only the newest may touch the layers. */
+        this.rebuilds = new Supersede();
+        this.sub = null;
+        this.hover = new SpatialHover({
+            is3d,
+            viewer: ctx.viewer,
+            port: session.port,
+            selection: session.selection,
+            dataset: () => session.latest?.[0] ?? null,
+            pick: (clientX, clientY, slackPx) => this.pickObservation(clientX, clientY, slackPx),
+            tiles: () => this.hoverTiles(),
+            toolActive: () => !!ctx.tools.regionOverlay?.toolActive,
+            outsideZone: (fn) => ctx.outsideZone(fn),
+            inZone: (fn) => ctx.inZone(fn),
+        });
+    }
+    /** Rebuild on every dataset, view, selection or colormap change. */
+    subscribeSpatial() {
+        this.sub?.unsubscribe();
+        this.sub =
+            this.session.changes$(this.ctx.store)?.subscribe(([dataset, view, selection, colormap, reverse]) => {
+                this.ctx.display.record(colormap ?? null, !!reverse);
+                // Kept so a slice change can redraw the markers for the new plane, which
+                // arrives through setZIndex rather than through any of these streams.
+                this.session.latest = [dataset, view, selection];
+                // What the markers are may have changed; where they are is the layers' own pick's
+                // business (it follows their data and the camera).
+                void this.hover.resolveSource(dataset, view);
+                void this.rebuild(dataset, view, selection);
+                this.afterChange();
+            }) ?? null;
+    }
+    /** Run after each rebuild is started (the 2D tile layers refresh here). */
+    afterChange() {
+        /* nothing by default */
+    }
+    hoverTiles() {
+        return null;
+    }
+    /** Stop following the data, drop the hover, and make every rebuild in flight stale. */
+    disposeSpatial() {
+        this.sub?.unsubscribe();
+        this.sub = null;
+        this.rebuilds.cancel();
+        this.hover.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subscription, combineLatest, of } from 'rxjs';\n\nimport { SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport { SpatialDataset } from '../../contracts/spatial-dataset.contract';\nimport { ColormapNode, SpatialViewState } from '../../contracts/display-types';\nimport { ExpressionField, ExpressionVolumeField } from '../../spatial/spatial-expression';\nimport { SpatialSelectionMask, emptySelection } from '../../spatial/spatial-selection';\nimport { SpatialSelectionStore } from '../../store/spatial-selection.service';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { Supersede } from '../../util/supersede';\nimport { ContrastWindowCache } from './napari-spatial-encoding';\nimport { SpatialHover } from './napari-spatial-hover';\nimport { NapariSpatialTileLayers, TranscriptEstimate } from './napari-spatial-tiles';\nimport { Rgb } from '../../contracts/colormap-lut';\nimport type { SceneContext } from './napari-scene';\n\n/** What the spatial subscription last saw: the dataset, the view state and the selection. */\nexport type SpatialLatest = [SpatialDataset | null, SpatialViewState, SpatialSelectionMask];\n\n/** Where the spatial tile layers' panel outputs go (the service's subjects and badge). */\nexport interface SpatialTileSinks {\n  /** The continuous LUT the view is using (so cells coloured by a gene match the markers). */\n  continuousLut(view: SpatialViewState): Rgb[];\n  estimateChanged(estimate: TranscriptEstimate | null): void;\n  geneCountsChanged(counts: Record<string, number> | null): void;\n  densityChanged(stats: { lo: number; hi: number; max: number }): void;\n  loadingChanged(layers: string[]): void;\n}\n\n/** The 2D scene the tile layers currently draw into. */\nexport interface SpatialTileOwner {\n  canvasSize(): [number, number];\n  /** Outlines appeared or disappeared: the markers' visibility follows. */\n  polygonsShownChanged(): void;\n}\n\n/** An estimated field and the inputs it was estimated for. */\nexport interface FieldCache<T> {\n  key: string | null;\n  field: T | null;\n}\n\n/**\n * The spatial state that outlives a scene (review Appendix B): what the subscription last saw, the\n * memoised percentile windows, the selection revision counter and the estimated gene-map FIELDS —\n * viewer-independent and expensive, so a re-plot recolours the cached field instead of estimating\n * it again. Everything that names a layer of a viewer belongs to the scene instead.\n */\nexport class SpatialSession {\n  /** Latest (dataset, view, selection) the spatial subscription saw — so a slice change can\n   *  rebuild the markers for the new plane, and the tile layers and the hover can read it. */\n  latest: SpatialLatest | null = null;\n  /** Spatial colouring's percentile windows, memoised per coloured vector (SPATIAL-12). */\n  readonly contrastWindows = new ContrastWindowCache();\n  /** The 2D gene map's field (the expensive half: it survives a recolour and a re-plot). */\n  readonly geneMap: FieldCache<ExpressionField> = { key: null, field: null };\n  /** The 3D gene map's field. */\n  readonly geneMapVolume: FieldCache<ExpressionVolumeField> = { key: null, field: null };\n  private lastSelectionSeen: SpatialSelectionMask | null = null;\n  private selectionRevision = 0;\n  /** Level-of-detail cell outlines, transcripts and density over the 2D view — created on first\n   *  use, only when a spatial port is bound, and kept across scenes (its tile caches with it). */\n  private tileLayers: NapariSpatialTileLayers | null = null;\n  private tileOwner: SpatialTileOwner | null = null;\n\n  constructor(\n    readonly port: SpatialDataPort | null,\n    readonly selection: SpatialSelectionStore | null,\n    private readonly sinks: SpatialTileSinks,\n  ) {}\n\n  /** The tile layers, if they were ever built. */\n  get tiles(): NapariSpatialTileLayers | null {\n    return this.tileLayers;\n  }\n\n  /**\n   * The tile layers, built on first use (null without a spatial port), now drawing for `owner`.\n   * Their host callbacks read the session's live state and the owner's canvas, so they never hold\n   * a stale dataset or colormap.\n   */\n  claimTiles(owner: SpatialTileOwner): NapariSpatialTileLayers | null {\n    const port = this.port;\n    if (!port) return null;\n    this.tileOwner = owner;\n    const sinks = this.sinks;\n    this.tileLayers ??= new NapariSpatialTileLayers(port, {\n      latest: () => this.latest,\n      canvasSize: () => this.tileOwner?.canvasSize() ?? [0, 0],\n      continuousLut: (view) => sinks.continuousLut(view),\n      estimateChanged: (e) => sinks.estimateChanged(e),\n      geneCountsChanged: (c) => sinks.geneCountsChanged(c),\n      loadingChanged: (layers) => sinks.loadingChanged(layers),\n      densityChanged: (d) => sinks.densityChanged(d),\n      polygonsShownChanged: () => this.tileOwner?.polygonsShownChanged(),\n    });\n    return this.tileLayers;\n  }\n\n  /** `owner`'s scene is going away: take the tile layers off its viewer. */\n  releaseTiles(owner: SpatialTileOwner): void {\n    if (this.tileOwner !== owner) return;\n    this.tileOwner = null;\n    this.tileLayers?.detach();\n  }\n\n  /**\n   * A revision number for a selection object.\n   *\n   * The store hands out a NEW mask object per change, so object identity is the\n   * cheap and exact way to tell two selections apart — a fingerprint over 3.7M\n   * mask bytes would be neither. Counting revisions keeps the cache key a short\n   * string.\n   */\n  selectionRev(selection: SpatialSelectionMask): number {\n    if (selection !== this.lastSelectionSeen) {\n      this.lastSelectionSeen = selection;\n      this.selectionRevision++;\n    }\n    return this.selectionRevision;\n  }\n\n  /**\n   * Everything a spatial scene redraws on: the dataset, the view state, the selection — and the\n   * display colormap and reverse flag, which are inputs here, not just something read at build\n   * time: `continuousColormap: null` means \"follow the image's colormap\", and a setting that only\n   * takes effect at the next unrelated rebuild is not one. Null without a spatial port.\n   */\n  changes$(\n    store: VisualizerStore,\n  ): Observable<[SpatialDataset | null, SpatialViewState, SpatialSelectionMask, unknown, boolean]> | null {\n    const port = this.port;\n    if (!port) return null;\n    const selection$ = this.selection?.getSelection$() ?? of(emptySelection());\n    return combineLatest([\n      port.getDataset$(),\n      store.getSpatialView$(),\n      selection$,\n      store.getColormap(),\n      store.getReverseScale(),\n    ]);\n  }\n}\n\n/**\n * What the 2D and 3D spatial scenes share: the subscription that redraws them, the hover over\n * them, and the latest-wins sequencing of their (async) rebuilds.\n */\nexport abstract class SpatialSceneBase {\n  protected readonly hover: SpatialHover;\n  /** Latest wins within the scene: a colour fetch is a round-trip, so a fast sequence of\n   *  colour-by changes can resolve out of order, and only the newest may touch the layers. */\n  protected readonly rebuilds = new Supersede();\n  private sub: Subscription | null = null;\n\n  protected constructor(\n    protected readonly ctx: SceneContext,\n    protected readonly session: SpatialSession,\n    is3d: boolean,\n  ) {\n    this.hover = new SpatialHover({\n      is3d,\n      viewer: ctx.viewer,\n      port: session.port,\n      selection: session.selection,\n      dataset: () => session.latest?.[0] ?? null,\n      pick: (clientX, clientY, slackPx) => this.pickObservation(clientX, clientY, slackPx),\n      tiles: () => this.hoverTiles(),\n      toolActive: () => !!ctx.tools.regionOverlay?.toolActive,\n      outsideZone: (fn) => ctx.outsideZone(fn),\n      inZone: (fn) => ctx.inZone(fn),\n    });\n  }\n\n  /** Rebuild on every dataset, view, selection or colormap change. */\n  protected subscribeSpatial(): void {\n    this.sub?.unsubscribe();\n    this.sub =\n      this.session.changes$(this.ctx.store)?.subscribe(([dataset, view, selection, colormap, reverse]) => {\n        this.ctx.display.record((colormap as ColormapNode) ?? null, !!reverse);\n        // Kept so a slice change can redraw the markers for the new plane, which\n        // arrives through setZIndex rather than through any of these streams.\n        this.session.latest = [dataset, view, selection];\n        // What the markers are may have changed; where they are is the layers' own pick's\n        // business (it follows their data and the camera).\n        void this.hover.resolveSource(dataset, view);\n        void this.rebuild(dataset, view, selection);\n        this.afterChange();\n      }) ?? null;\n  }\n\n  /** (Re)build the scene's layers for the current dataset + view state. */\n  protected abstract rebuild(\n    dataset: SpatialDataset | null,\n    view: SpatialViewState,\n    selection?: SpatialSelectionMask,\n  ): Promise<void>;\n  /** Run after each rebuild is started (the 2D tile layers refresh here). */\n  protected afterChange(): void {\n    /* nothing by default */\n  }\n  /** The observation drawn under a client position, or -1 (see `SpatialHoverHost.pick`). */\n  protected abstract pickObservation(clientX: number, clientY: number, slackPx: number): number;\n  protected hoverTiles(): NapariSpatialTileLayers | null {\n    return null;\n  }\n\n  /** Stop following the data, drop the hover, and make every rebuild in flight stale. */\n  protected disposeSpatial(): void {\n    this.sub?.unsubscribe();\n    this.sub = null;\n    this.rebuilds.cancel();\n    this.hover.dispose();\n  }\n}\n"]}