@jax-data-science/sci-image-visualizer 0.3.3 → 0.5.0

package/README.md

@@ -83,7 +83,7 @@ full walkthrough (adapters, TIFF handling, the Angular-17 toolchain note).
   one `IVisualizer` contract; the host picks per plot type via `RoutingVisualizerService`.
 - **Plot types** — Image (OSD), Plotly (Heatmap, Contour, Scatter 2D, Surface 3D,
   Scatter 3D, Isosurface), and napari · WebGPU (Image, Scatter 2D, Surface,
-  Scatter 3D, Volume, Isosurface).
+  Scatter 3D, Volume, Isosurface, **Spatial omics**, **Spatial omics 3D**).
 - **Region / annotation tools** — selection, rectangle, polyline, freeform,
   polygon + vertex editing, move, Bézier↔polygon, magic wand, brush, vertex eraser.
 - **Channels & histogram** — brightness/contrast/gamma, per-channel display,
@@ -143,7 +143,8 @@ data as you zoom in:
 ### napari-js — WebGPU
 GPU-accelerated renderings via [napari-js](https://www.npmjs.com/package/napari-js)
 (WebGPU), selectable from the plot-type menu as the "napari · WebGPU" variants of
-Image, Scatter 2D, Surface, Scatter 3D, **Volume**, and **Isosurface**. It
+Image, Scatter 2D, Surface, Scatter 3D, **Volume**, **Isosurface**, and the two
+spatial-omics modes ([below](#spatial-omics)). It
 assembles the volume from the slice endpoints with a runtime **decimate factor**
 (resolution slider, default ½), a surface **wireframe** toggle, a 3D **axes / scale
 gizmo**, an in-view **Z-height drag handle** for the volume, **cancellable** loading,
@@ -151,8 +152,16 @@ and **multichannel volume** compositing (one additive tinted layer per channel).
 Regions and display options stay in sync with the other backends via the shared
 stores.
 
-When a stack is open, a slice slider (Image view) or single-image/stack toggle
-(other views) navigates the z-dimension. A stack may be one server-tiled file
+Volume and Isosurface take their voxels from the **image stack**, and only from
+it — there is one voxel path, so a dataset reaches those modes by being a stack.
+A stack that declares its slice spacing (`imageMeta[0].mppZ`, alongside
+`mppX`/`mppY`) is rendered at its **true physical extent**, so 40 × 40 × 200 µm
+voxels read as anatomy rather than as a cube-aspect brick, and the axis labels
+read in real units on all three axes. Without it the world box is
+resolution-invariant but shape-only, and Z is labelled in slices.
+
+When a stack is open, a slice slider (Image view, and the 2D Spatial omics view)
+or single-image/stack toggle (other views) navigates the z-dimension. A stack may be one server-tiled file
 (internal z) or a set of self-contained per-slice URLs (`IImageInfo.tiled ===
 false`) — the latter (e.g. a host-assembled folder of numbered files) fetches
 `urls[z]` per slice on demand. For a per-slice stack the host can also supply a
@@ -164,6 +173,187 @@ A line-ROI tool draws coloured lines and plots intensity along each one in a liv
 floating inset chart that re-samples at the current zoom. It works today but the
 API/UX are still stabilizing (see [In progress / roadmap](#in-progress--roadmap)).
 
+## Spatial omics
+
+Contracts for **spatial-omics datasets**: N observations (Visium spots,
+segmented cells) positioned in a tissue image's pixel space, each carrying
+categorical and continuous annotations plus a lazily-fetched feature (gene)
+matrix.
+
+```ts
+import {
+  SPATIAL_DATA_PORT, SpatialDataHttpService, SpatialDataset,
+} from '@jax-data-science/sci-image-visualizer';
+
+providers: [
+  SpatialDataHttpService,
+  { provide: SPATIAL_DATA_PORT, useExisting: SpatialDataHttpService },
+]
+```
+
+Like `TILE_ACCESS_PORT`, this is a **port**: the library consumes typed arrays
+and never learns how the data is stored. `SpatialDataHttpService` is an optional
+reference adapter for the format the bundled example server speaks; a host with
+its own backend implements `SpatialDataPort` instead and imports neither.
+
+Two properties the design turns on:
+
+- **Metadata is eager, values are lazy.** A `SpatialDataset` holds coordinates
+  plus column and feature *descriptors*; vectors arrive one at a time, for the
+  one column or gene being displayed. A Visium table is ~31k genes wide — the
+  dense matrix is ~800 MB — so loading a dataset can never mean loading its
+  matrix.
+- **Struct-of-arrays, not object-per-cell.** Datasets run 10³ (Visium) to 10⁶
+  (Xenium/CosMx) observations; two `Float32Array`s beat 500k `{x, y}` objects
+  and upload to the GPU without a copy.
+
+Once a dataset is published, the spatial plot types appear in the selector (and
+disappear when it is cleared — the same gating that hides Volume without a
+z-stack):
+
+- **Spatial omics** — one marker per observation over the tissue image the
+  coordinates live in, positioned through `imageRef`'s affine.
+- **Spatial omics 3D** — gated additionally on the observations carrying a `z`
+  (`requiresSpatial3d`): the same observations as a point cloud under an orbit
+  camera, inside the dataset's reference volume if it has one.
+
+**A dataset whose 3D data is one file gets an image made from it.** A registered
+volume (`SpatialDataset.volume` + `SpatialDataPort.getVolume()`) is published *as*
+a grayscale z-stack image — one plane per slice, opened mid-volume — so the whole
+image surface applies to it: the toolbar slice slider, the contrast window,
+colormaps, the region tools, the physical scale bar, and Volume / Isosurface
+through the ordinary stack path. In the 2D mode the displayed plane then draws
+**that plane's** observations over that plane's anatomy, in the volume's own pixel
+grid, and a region drawn there selects that plane's cells rather than the whole
+depth behind them.
+
+**Cluster density volumes** *(3D mode, optional)* — a checkbox that raymarches
+each cluster as a smooth density field beside the cloud, tinted with its legend
+colour and blended additively. Serial sections hundreds of microns apart cannot be
+read as an anatomical distribution from points alone: the eye will not integrate a
+stack of discs into a shape, and every gap between sections reads as absence.
+Individual cells are never interpolated — consecutive sections sample different
+cells, so there is nothing to interpolate along — but a density *field* is an
+estimate legitimately defined between the imaged planes, and it renders as a
+translucent cloud so it cannot be mistaken for measurement. The kernel is
+anisotropic (σ along z clears one section gap) and the field is coverage-normalised
+along z, so unimaged planes do not read as empty tissue.
+
+In **3D** the same `Gene map` checkbox draws one field per imaged section, at its
+own depth, with the gaps between sections empty — the measured slides, stacked.
+`One map section at a time` isolates a single sheet (its own control, separate from
+the cloud's, so every combination stays reachable), and `Volume rendering
+(interpolate along z)` smooths the sheets into a continuous volume. The last is a
+different object and the panel labels it as one: the planes between sections then
+carry an estimate smoothed from their neighbours' mean, nothing is drawn past the
+outermost section, and the section restriction is ignored because a volume built
+from one slide would smear it through the whole specimen. It is estimated on the
+reference volume's lattice — coarsened in-plane but never along z, so one plane is
+one section — and shares the 2D map's bandwidth, window and colormap.
+
+**Show** *(3D mode)* — the reference volume, the observation cloud and the cluster
+density volumes share one space, so any two of them hide each other; 374k points
+drawn as a stack of discs hide the density volumes almost entirely. Each is
+toggled independently, so every combination is reachable — the estimated fields
+alone, the fields with the anatomy behind them, the anatomy on its own. These are
+visibility only: the layers stay built, so a toggle never re-fetches the template
+or re-rasterises a field, and none of them re-frames the orbit camera. (The
+density checkbox is the exception and still gates construction, since building six
+volumes is not free.) **Volume opacity** is the backdrop's own slider, separate
+from the markers': reading the cloud or a density field *through* the anatomy
+means turning the anatomy down, not the data over it. **One section at a time** restricts the cloud to a single
+imaged section, which is how you check whether the estimated field follows the
+cells that were actually measured. Sections are the distinct z of the
+observations — every cell on a slide shares that slide's registered z, so no
+section-label column is needed — and a dataset whose z is continuous rather than
+sectioned is offered no section control instead of having one invented for it.
+
+**Hover and click** — hovering an observation names it in a cursor tooltip: the
+class for a categorical column, the value with its unit for a gene or numeric one,
+and nothing at all when no colour source is set (there is no cluster to name).
+Clicking a marker selects that whole class, the same selection the legend's rows
+produce, and clicking it again clears. Because a click means "select" here,
+napari's click-to-zoom is off in the spatial modes — the wheel, the zoom buttons
+and the zoom-box tool still zoom. A gene cannot be clicked to select: no set of
+cells "is" a value.
+
+**Colormap** *(continuous colouring)* — the low→high gradient for a gene or a
+numeric column, chosen from the library's own `COLORMAP_OPTIONS` with the same
+swatch previews the image's colormap picker uses. It defaults to following the
+image's colormap (with a Viridis fallback, since a grey measurement over grey
+anatomy cannot be told apart from it), and clearing the picker returns to that.
+One setting drives the markers, both gene maps and the panel's colour bar, so none
+of them can disagree about what a colour means.
+
+**Gene map** *(2D mode, optional, with a gene selected)* — a checkbox that draws
+the selected gene's expression as a smooth field *beneath* the cells. Coloured
+markers answer "which cells express this gene"; they do not answer "where is it
+expressed", because the eye cannot integrate thousands of small dots into a
+territory. The field is the kernel-weighted **mean per cell, not a sum** — a sum
+would make a crowded region glow whatever its cells were doing — and smoothing the
+numerator and denominator together spreads *where*, not *how much*. That
+denominator is also what lets the layer say nothing: where no cell was measured the
+mean is undefined rather than zero, so those pixels stay fully transparent instead
+of taking the colormap's low end, and alpha ramps with local support so a thinly
+sampled pixel reads as tentative. `Smoothing` sets the kernel σ; `Map opacity` is
+the field's own opacity, separate from the markers' — turn the markers down to read
+the field under them. On a volume-backed dataset the field is re-estimated per
+plane from that plane's cells.
+
+Colour it through `getSpatialControls()`:
+
+```ts
+const controls = viz.getSpatialControls();   // null unless a port is bound
+controls?.colorByColumn('region');           // categorical -> the column's palette
+controls?.colorByFeature('Ttr');             // gene -> colormap, log, percentile-clipped
+controls?.setViewState({ pointScale: 2 });
+```
+
+The view state lives in the shared store, so the controls work before any
+backend has mounted and survive a plot-type switch.
+
+The [example server](examples/tile-server/README.md#spatial-omics-endpoints)
+implements the endpoints, and `npm run make-spatial-demo` generates a synthetic
+Visium-geometry dataset **and a matching tissue image** so the
+[browser example](examples/browser-image/README.md#spatial-omics-demo) runs the
+whole path with no download. A converter for real SpatialData Zarr stores ships
+alongside it.
+
+A **Spatial omics** controls panel (`<spatial-controls>`, opened from the
+toolbar) drives all of this from the UI: a column dropdown, a gene search over
+the feature panel, a legend for categorical colourings and a colour bar for
+continuous ones, plus point-size, opacity, log-scale and outlier-clip controls.
+Its legend swatches and colour bar are built with the same functions the
+renderer uses, so the key cannot drift from the canvas.
+
+**Selection** reuses the region tools you already have: draw a rectangle,
+polygon, freehand shape, wand or brush region, then *Select from ROIs* selects
+every observation inside their union and mutes the rest. Legend rows select
+their category on click.
+
+**Linked distributions** sit in the same panel, below the colour controls, over
+whatever the map is coloured by: histogram, violin or box for a continuous column
+or a gene, and per-category **counts** for a categorical one — a histogram of a
+category code would be meaningless, but "how many cells per class" is the question
+the legend implies and never answers. Violin and box are splittable by a
+categorical column. One dialog on purpose — changing the gene
+and watching the distribution move is a single action. They follow the selection: the histogram
+overlays *Selected* on the full distribution, violin and box narrow to it. The
+chart's subject is the map's colour source rather than an independent picker, so
+the two cannot disagree about what is being shown.
+
+Categorical colouring has one renderer-specific limit worth knowing: the 3D
+points layer maps a per-point scalar through a 256-entry LUT, which keeps 96
+blocks apart exactly — one of them reserved for a missing value, so **95
+categories** fit — and above that the cloud draws flat and the panel says so.
+The 2D markers (per-point RGBA) and the density volumes (a scalar field per
+cluster) have no such limit — which is why the example server serves `subclass`
+(338) even though the cloud cannot colour by it.
+
+Still to build: hover tooltips, chart → map brushing, and a GPU layer for cell
+boundary polygons (they are served, not yet drawn) — see
+[docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md).
+
 ## Regions & annotation
 
 Regions are stored in a shared **region store** and use a GeoJSON-friendly model
@@ -270,6 +460,16 @@ Work that is landed-but-unstable or planned (not yet available):
   and browser-side SAM/cellpose segmentation) against sample images — so the
   library can be evaluated and developed standalone, outside jit-ui. Tracked in
   the library-extraction SOW ([docs/JIT_UI_visualization_library_SOW.docx](docs/JIT_UI_visualization_library_SOW.docx)).
+- **Spatial-omics follow-ons** *(planned — the modes themselves shipped in
+  0.4.0, see [Spatial omics](#spatial-omics))* — hover tooltips over
+  observations, brushing a chart selection back onto the map, and a GPU shapes
+  layer for cell-boundary polygons (the example server serves them; nothing draws
+  them yet, since a DOM overlay will not hold 10⁴–10⁵ outlines). The GPU layer is
+  measured as feasible — generating the geometry in a compute pass is bit-exact
+  and ~16× faster than JS, and 10⁵–10⁶ outlines draw in single-digit
+  milliseconds; the constraint is napari-js's closed renderer, not WebGPU. See
+  [.planning/research/cell-boundary-polygons-webgpu.md](.planning/research/cell-boundary-polygons-webgpu.md)
+  and [docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md).
 - **SAM 3 model** *(planned)* — a `variant: 'sam3'` decoder path + export tooling
   (SAM 2/3 use a different mask I/O than the current SAM-v1 path). See
   [docs/sam-segmentation-design.md](docs/sam-segmentation-design.md).
@@ -284,6 +484,10 @@ Design, architecture, and planning docs for the library:
 - **[docs/sam-segmentation-design.md](docs/sam-segmentation-design.md)** — design of
   the browser SAM segmentation: model choice, ONNX export/quantization recipe,
   encoder/decoder I/O, the engine/session architecture, and the rollout phases.
+- **[docs/spatial-omics-plot-mode-design.md](docs/spatial-omics-plot-mode-design.md)** —
+  design and phased plan for the spatial-omics plot mode: current-state audit,
+  what the CosMx / Spatial-Live / SpatialData references contribute, the data
+  plane, MoSCoW requirements, and the open questions still to settle.
 - **Architecture diagrams**
   - [docs/jit-ui-visualization-architecture.mmd](docs/jit-ui-visualization-architecture.mmd)
     ([PNG](docs/img/jit-ui-visualization-architecture.png) ·
@@ -376,6 +580,66 @@ jit-ui's `app.module.ts` for a full wiring example.
 Each embeddable component uses a plain, unprefixed selector: `visualizer`,
 `region-editor`, `plotting-toolbar`, `channel-histogram`, `hex-color-picker`.
 
+## Contributed plot types
+
+Another package can add a mode to the plot-type selector at runtime, through
+Angular DI — the same way `TOOLBAR_TOOLS` contributes toolbar tools. Nothing
+registers at import time: a mode appears only when the host provides it on the
+`PLOT_TYPE_CONTRIBUTIONS` multi-provider token, and with no provider the
+library behaves exactly as before. A contribution is a plain object, so the
+contributing package needs no Angular compiler and no decorators.
+
+```ts
+import {
+  PLOT_TYPE_CONTRIBUTIONS, PlotType, PlotTypeContribution,
+} from '@jax-data-science/sci-image-visualizer';
+
+const myMode: PlotTypeContribution = {
+  descriptor: {
+    type: 'my-mode',                  // namespaced; must not clash with a PlotType
+    label: 'Image + my overlay',      // test-mode label
+    productionLabel: 'My overlay',    // omit to make the mode test-only
+    icon: 'pi pi-pencil',
+    dimensions: '2d',
+    baseType: PlotType.IMAGE,         // v1: only the OpenSeadragon Image view
+  },
+  activate(ctx) {
+    // ctx.visualizer — the public IVisualizer (regions, region overlay, undo…)
+    // ctx.viewport  — overlay container, dataToClient / clientToData, frame$ / settled$
+    // ctx.imageInfo$ — the current image
+    const sub = ctx.viewport.frame$.subscribe((visible) => redraw(visible));
+    return { deactivate: () => sub.unsubscribe() };
+  },
+  // Optional side panel, in the right-hand panel area while the mode is active.
+  // Either an Angular component (it can inject PLOT_MODE_CONTEXT / PLOT_MODE_SESSION)…
+  //   panel: { title: 'My overlay', component: MyPanelComponent },
+  // …or plain DOM, for a package built without the Angular compiler:
+  panel: {
+    title: 'My overlay',
+    mount(host, ctx, session) {
+      host.textContent = 'Hello';
+      return () => { host.textContent = ''; };   // teardown
+    },
+  },
+};
+
+// Host composition root:
+providers: [{ provide: PLOT_TYPE_CONTRIBUTIONS, useValue: myMode, multi: true }]
+```
+
+Selecting the mode plots exactly as its `baseType` would (same backend, toolbar,
+region tools and wheel handling), then calls `activate(ctx)` once the viewport
+is ready. `session.deactivate()` runs exactly once when the user leaves the
+mode, when the image changes (a fresh session starts for the new image), or
+when the visualizer is destroyed. Anything a contribution throws or rejects is
+caught and logged. Failing to start falls back to `baseType`, and so does failing
+to clean up when the same mode is about to be re-activated (re-render, image
+switch). Contributed descriptors take the same `requiresGrayscale`,
+`requiresStack`, `requiresSpatialData` and `requiresSpatial3d` gates as the
+built-ins. The full contract
+and its guarantees are documented in
+[`plot-type-contribution.contract.ts`](./src/lib/contracts/plot-type-contribution.contract.ts).
+
 ## Development
 
 ```bash

package/esm2022/index.mjs

@@ -12,18 +12,33 @@ export * from './lib/contracts/ports/image-state.port';
 export * from './lib/contracts/ports/tile-access.port';
 export * from './lib/contracts/ports/region-io.port';
 export * from './lib/contracts/ports/preferences.port';
+export * from './lib/contracts/ports/spatial-data.port';
+export * from './lib/contracts/spatial-dataset.contract';
 export * from './lib/contracts/channel-histogram-api.contract';
 export * from './lib/contracts/viz-config';
 export * from './lib/contracts/image.contract';
 export * from './lib/contracts/plot-type';
 export * from './lib/contracts/toolbar-config';
 export * from './lib/contracts/toolbar-tool.contract';
+export * from './lib/contracts/plot-type-contribution.contract';
 export * from './lib/contracts/capabilities.contract';
 export * from './lib/contracts/region-overlay.contract';
 export * from './lib/contracts/display-types';
 export * from './lib/contracts/sam.contract';
 export * from './lib/contracts/cell-segmenter.contract';
 export { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';
+// ── Spatial-omics data plane ─────────────────────────────────────────────
+// The wire format the bundled example server speaks, plus a ready-made
+// SpatialDataPort adapter for it. Both are OPTIONAL: a host with its own
+// backend implements SpatialDataPort directly and imports neither.
+export { SpatialDataHttpService, SupersededError } from './lib/implementations/spatial-data-http/spatial-data-http.service';
+export { SPATIAL_WIRE_VERSION, isLittleEndian, assertManifestVersion, datasetFromManifest, decodeCoords, decodeRadius, decodeColumn, decodeFeatureVector, decodePolygons, } from './lib/implementations/spatial-data-http/spatial-wire';
+// Backend-neutral encodings: columns/genes -> per-point colours and sizes.
+export { encodeCategorical, encodeContinuous, resolveCategoryColors, contrastWindow, markerDiameters, toRgbaTuples, lutFor, DEFAULT_CATEGORICAL_PALETTE, DEFAULT_MUTED_OPACITY, MISSING_COLOR, } from './lib/spatial/spatial-encoding';
+// Selection: which observations fall inside the drawn ROIs, and the shared store
+// that holds the answer.
+export { selectInRegions, selectByCategory, mutedFromSelection, pointInRing, emptySelection, countMask, maskToIndices, } from './lib/spatial/spatial-selection';
+export { SpatialSelectionStore } from './lib/store/spatial-selection.service';
 export * from './lib/contracts/instance-segmenter.contract';
 export * from './lib/contracts/semantic-segmenter.contract';
 // ── Generic client-side image utilities (shared with the host's pipeline) ──
@@ -52,4 +67,9 @@ export { VisualizerComponent } from './lib/visualizer.component';
 export { RegionEditorComponent } from './lib/region-editor/region-editor.component';
 export { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';
 export { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';
-//# sourceMappingURL=data:application/json;base64,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
+export { SpatialControlsComponent, } from './lib/spatial-controls/spatial-controls.component';
+export { SpatialChartsComponent } from './lib/spatial-controls/spatial-charts/spatial-charts.component';
+// Pure chart builders, exported so a host can render the same distributions
+// wherever it likes (a report, a different charting surface).
+export { buildOmicsTraces, omicsLayout, benefitsFromGrouping, } from './lib/implementations/plotly/omics-trace-builders';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4EAA4E;AAC5E,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,yCAAyC,CAAC;AACxD,cAAc,0CAA0C,CAAC;AACzD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,iDAAiD,CAAC;AAChE,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AAEjG,4EAA4E;AAC5E,uEAAuE;AACvE,yEAAyE;AACzE,mEAAmE;AACnE,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,mEAAmE,CAAC;AAC5H,OAAO,EACL,oBAAoB,EAAE,cAAc,EAAE,qBAAqB,EAAE,mBAAmB,EAChF,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,cAAc,GAC9E,MAAM,sDAAsD,CAAC;AAI9D,2EAA2E;AAC3E,OAAO,EACL,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,cAAc,EAC1E,eAAe,EAAE,YAAY,EAAE,MAAM,EACrC,2BAA2B,EAAE,qBAAqB,EAAE,aAAa,GAClE,MAAM,gCAAgC,CAAC;AAIxC,iFAAiF;AACjF,yBAAyB;AACzB,OAAO,EACL,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,WAAW,EAClE,cAAc,EAAE,SAAS,EAAE,aAAa,GACzC,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAE5D,8EAA8E;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAoB,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,6EAA6E;AAC7E,OAAO,EACL,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAC/E,kBAAkB,EAAE,oBAAoB,GACzC,MAAM,+CAA+C,CAAC;AAEvD,8EAA8E;AAC9E,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAE/F,4EAA4E;AAC5E,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,4EAA4E;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,6DAA6D;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC;AAChG,OAAO,EACL,wBAAwB,GACzB,MAAM,mDAAmD,CAAC;AAE3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gEAAgE,CAAC;AACxG,4EAA4E;AAC5E,8DAA8D;AAC9D,OAAO,EACL,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,GACpD,MAAM,mDAAmD,CAAC","sourcesContent":["/**\n * Public API of the jax-image-visualization library. External consumers import\n * ONLY from here (`@jax-data-science/sci-image-visualizer`); everything else under `lib/` is\n * internal. The surface is contracts + tokens + neutral models + the Angular\n * module, plus the routing service the host's composition root binds the tokens\n * to (`useExisting`).\n */\n\n// ── Contracts & DI tokens ────────────────────────────────────────────────\nexport * from './lib/contracts/visualizer.contract';\nexport * from './lib/contracts/region-editor-api.contract';\nexport * from './lib/contracts/ports/image-state.port';\nexport * from './lib/contracts/ports/tile-access.port';\nexport * from './lib/contracts/ports/region-io.port';\nexport * from './lib/contracts/ports/preferences.port';\nexport * from './lib/contracts/ports/spatial-data.port';\nexport * from './lib/contracts/spatial-dataset.contract';\nexport * from './lib/contracts/channel-histogram-api.contract';\nexport * from './lib/contracts/viz-config';\nexport * from './lib/contracts/image.contract';\nexport * from './lib/contracts/plot-type';\nexport * from './lib/contracts/toolbar-config';\nexport * from './lib/contracts/toolbar-tool.contract';\nexport * from './lib/contracts/plot-type-contribution.contract';\nexport * from './lib/contracts/capabilities.contract';\nexport * from './lib/contracts/region-overlay.contract';\nexport * from './lib/contracts/display-types';\nexport * from './lib/contracts/sam.contract';\nexport * from './lib/contracts/cell-segmenter.contract';\nexport { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';\n\n// ── Spatial-omics data plane ─────────────────────────────────────────────\n// The wire format the bundled example server speaks, plus a ready-made\n// SpatialDataPort adapter for it. Both are OPTIONAL: a host with its own\n// backend implements SpatialDataPort directly and imports neither.\nexport { SpatialDataHttpService, SupersededError } from './lib/implementations/spatial-data-http/spatial-data-http.service';\nexport {\n  SPATIAL_WIRE_VERSION, isLittleEndian, assertManifestVersion, datasetFromManifest,\n  decodeCoords, decodeRadius, decodeColumn, decodeFeatureVector, decodePolygons,\n} from './lib/implementations/spatial-data-http/spatial-wire';\nexport type {\n  SpatialManifest, SpatialDatasetSummary, SpatialRadiusSpec,\n} from './lib/implementations/spatial-data-http/spatial-wire';\n// Backend-neutral encodings: columns/genes -> per-point colours and sizes.\nexport {\n  encodeCategorical, encodeContinuous, resolveCategoryColors, contrastWindow,\n  markerDiameters, toRgbaTuples, lutFor,\n  DEFAULT_CATEGORICAL_PALETTE, DEFAULT_MUTED_OPACITY, MISSING_COLOR,\n} from './lib/spatial/spatial-encoding';\nexport type {\n  RGBA, CategoricalEncodingOptions, ContinuousEncodingOptions,\n} from './lib/spatial/spatial-encoding';\n// Selection: which observations fall inside the drawn ROIs, and the shared store\n// that holds the answer.\nexport {\n  selectInRegions, selectByCategory, mutedFromSelection, pointInRing,\n  emptySelection, countMask, maskToIndices,\n} from './lib/spatial/spatial-selection';\nexport type { SpatialSelectionMask } from './lib/spatial/spatial-selection';\nexport { SpatialSelectionStore } from './lib/store/spatial-selection.service';\nexport * from './lib/contracts/instance-segmenter.contract';\nexport * from './lib/contracts/semantic-segmenter.contract';\n\n// ── Generic client-side image utilities (shared with the host's pipeline) ──\nexport { ProcessingImage } from './lib/processing/processing-image';\nexport { cropImage, CropImageOptions } from './lib/processing/image-crop';\nexport { ImageConverterService } from './lib/processing/image-converter.service';\n\n// ── SAM model registry (host configures hosted ONNX URLs once available) ──\nexport {\n  SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls,\n  setDefaultSamModel, getDefaultSamModelId,\n} from './lib/toolbar/segmentation/sam-model-registry';\n\n// ── onnxruntime-web WASM location (host overrides once, at app init) ───────\nexport { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';\n\n// ── Neutral data models ──────────────────────────────────────────────────\nexport * from './lib/models/region';\nexport * from './lib/models/class-preset';\nexport { ShapeSelection } from './lib/models/shape';\n\n// ── Angular module + composition-root service ────────────────────────────\nexport { VisualizationModule } from './lib/visualization.module';\nexport { RoutingVisualizerService } from './lib/routing-visualizer.service';\n// Provider factory for an isolated, component-scoped viewer instance (e.g. a\n// modal that must not share the main viewer's region/image state).\nexport { provideVisualization } from './lib/provide-visualization';\n\n// ── Public components (exported by VisualizationModule) ───────────────────\n// ng-packagr requires module-exported components to be reachable from the\n// entry point so consumers get their types; these are the embeddable elements\n// (`<visualizer>`, `<region-editor>`, `<hex-color-picker>`).\nexport { VisualizerComponent } from './lib/visualizer.component';\nexport { RegionEditorComponent } from './lib/region-editor/region-editor.component';\nexport { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';\nexport { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';\nexport {\n  SpatialControlsComponent,\n} from './lib/spatial-controls/spatial-controls.component';\nexport type { SpatialLegendEntry } from './lib/spatial-controls/spatial-controls.component';\nexport { SpatialChartsComponent } from './lib/spatial-controls/spatial-charts/spatial-charts.component';\n// Pure chart builders, exported so a host can render the same distributions\n// wherever it likes (a report, a different charting surface).\nexport {\n  buildOmicsTraces, omicsLayout, benefitsFromGrouping,\n} from './lib/implementations/plotly/omics-trace-builders';\nexport type {\n  OmicsChartKind, OmicsGrouping, OmicsTraceInput,\n} from './lib/implementations/plotly/omics-trace-builders';\n"]}

package/esm2022/lib/contracts/display-types.mjs

@@ -4,5 +4,23 @@
  * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)
  * keep compiling unchanged while consumers finally get named shapes.
  */
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+export const DEFAULT_SPATIAL_VIEW = {
+    colorBy: null,
+    pointScale: 1,
+    opacity: 1,
+    logScale: false,
+    percentileClip: [0.01, 0.99],
+    continuousColormap: null,
+    showVolume: true,
+    volumeOpacity: 0.5,
+    showPoints: true,
+    pointSection: null,
+    densityVolume: false,
+    densitySmoothing: 1,
+    geneMap: false,
+    geneMapSection: null,
+    geneMapVolume: false,
+    geneMapSmoothing: 1,
+    geneMapOpacity: 0.85,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"display-types.js","sourceRoot":"","sources":["../../../../src/lib/contracts/display-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2KH,MAAM,CAAC,MAAM,oBAAoB,GAAqB;IACpD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,CAAC;IACb,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IAC5B,kBAAkB,EAAE,IAAI;IACxB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,GAAG;IAClB,UAAU,EAAE,IAAI;IAChB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,OAAO,EAAE,KAAK;IACd,cAAc,EAAE,IAAI;IACpB,aAAa,EAAE,KAAK;IACpB,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,IAAI;CACrB,CAAC","sourcesContent":["/**\n * Publication-critical types that were `any` on the public contracts\n * (refactoring plan, Step 6). Deliberately permissive — every field optional —\n * so existing hosts (which pass PrimeNG `TreeNode`s and plain option objects)\n * keep compiling unchanged while consumers finally get named shapes.\n */\n\n/** A colormap value as Plotly understands it: a built-in scale name (e.g.\n *  'Viridis') or an inline array of `[stop, color]` pairs. */\nexport type ColormapValue = string | Array<[number, string]>;\n\n/** One node of the colormap selector tree (structurally compatible with the\n *  PrimeNG `TreeNode`s the host passes): group nodes carry `children`, leaf\n *  nodes carry the scale in `data.value` (+ a preview image in `data.src`). */\nexport interface ColormapNode {\n  label?: string;\n  data?: { value?: ColormapValue; src?: string };\n  children?: ColormapNode[];\n}\n\n/** Magic-wand pixel-comparison space. */\nexport type WandType = 'GRAY' | 'RGB' | 'LAB_DISTANCE';\n\n/** Options for the magic-wand tool (QuPath-style). */\nexport interface IWandOptions {\n  type?: WandType;\n  /** Gaussian sigma applied to the patch before thresholding. */\n  sigma?: number;\n  /** Higher = stricter (smaller selection) for GRAY/RGB; higher = looser for\n   *  LAB_DISTANCE — matches QuPath. */\n  sensitivity?: number;\n  /** Square patch size in pixels (must be odd). */\n  patchSize?: number;\n  /** When true, skip blur/threshold and flood-fill at exact-match\n   *  (Cmd/Ctrl-click in QuPath). */\n  simpleMode?: boolean;\n}\n\n/** Options for the brush region tool (QuPath-style). */\nexport interface IBrushOptions {\n  /** Brush diameter in matrix (image) pixels. */\n  size?: number;\n}\n\n/** What drives point colour in the spatial-omics mode: an annotation column\n *  from the dataset, or one feature (gene) vector fetched on demand. */\nexport interface SpatialColorBy {\n  kind: 'column' | 'feature';\n  name: string;\n}\n\n/** Display state for the spatial-omics plot mode. Lives in `VisualizerStore`\n *  alongside the colormap/channel state so the renderer reacts to edits the\n *  same way it does for an image. */\nexport interface SpatialViewState {\n  /** Colour source; `null` renders every observation in one neutral colour\n   *  (useful on its own — it shows where the tissue actually is). */\n  colorBy: SpatialColorBy | null;\n  /** Multiplier on the dataset's physical marker size. 1 = true size, which for\n   *  a 55 µm Visium spot is correct but can be invisible when zoomed out. */\n  pointScale: number;\n  /** Alpha for points that are not muted. */\n  opacity: number;\n  /** Log-scale continuous values before mapping them onto the colormap. Seeded\n   *  from the column's `logScaleHint` — count data needs it. */\n  logScale: boolean;\n  /** Percentile clip for the contrast window as `[lo, hi]` fractions, so a\n   *  handful of saturated observations don't flatten the rest. */\n   percentileClip: [number, number];\n  /**\n   * Colormap for CONTINUOUS spatial colouring — a gene, a numeric column — as a\n   * {@link ColormapValue}, the same shape the display colormap carries: a scale\n   * NAME for the built-ins, or an inline `[stop, colour]` array for the rest.\n   * Null follows the display colormap.\n   *\n   * Its own setting because the display colormap belongs to the tissue image and\n   * is usually a grey ramp, which is the wrong thing to read a measurement\n   * through: grey over grey cannot be told apart from the anatomy. Following it\n   * (with a Viridis fallback for exactly that case) is a reasonable default and a\n   * poor ceiling, since which gradient reads best is a judgement about the data.\n   *\n   * One setting for the markers, the 2D gene map and the 3D gene map together, so\n   * the field under the cells and the cells over it cannot disagree about what a\n   * colour means — and the panel's own colour bar is built from it too.\n   */\n  continuousColormap: ColormapValue | null;\n  /**\n   * What the 3D scene draws. The three things in it — the reference volume, the\n   * observation cloud and the cluster density volumes — occupy the same space, so\n   * any two of them hide each other to some degree. These are independent because\n   * the useful views are the combinations: the volumes alone to read an estimated\n   * distribution, one section's cells over them to check that estimate against the\n   * measurement, the anatomy alone to find a landmark.\n   *\n   * Visibility only — the layers stay built, so toggling one back on is immediate\n   * and does not re-run a rasterisation. {@link densityVolume} is the exception and\n   * genuinely gates construction, because building six volumes is not free.\n   */\n  showVolume: boolean;\n  /**\n   * The reference volume's opacity.\n   *\n   * Its own, not {@link opacity} (which belongs to the markers): the volume is a\n   * BACKDROP, and reading the cloud or a density field through it means turning\n   * the anatomy down without touching the data drawn over it. Ranges lower than\n   * the markers' slider for the same reason — a faint anatomical hint is a useful\n   * setting for a backdrop and a useless one for the measurement.\n   */\n  volumeOpacity: number;\n  /** Draw the observation cloud (3D). */\n  showPoints: boolean;\n  /**\n   * Restrict the cloud to ONE imaged section, by index into the dataset's sampled\n   * sections; null draws every section.\n   *\n   * The whole cloud is a stack of discs that hides whatever is drawn between them.\n   * One section at a time is the view that answers \"does the estimated field\n   * actually follow the cells I measured\" — and it is only offered for data that\n   * really is sectioned (see `sampledSections`).\n   */\n  pointSection: number | null;\n  /**\n   * Draw each cluster as a translucent DENSITY volume alongside the 3D cloud.\n   *\n   * Serial sections hundreds of microns apart make a cloud hard to read as an\n   * anatomical distribution — the eye cannot integrate discs into a shape. A\n   * density field can be estimated between the imaged planes (a continuous\n   * estimate, unlike individual cells, which have no correspondence to\n   * interpolate along) and renders as a cloud that reads as an estimate.\n   */\n  densityVolume: boolean;\n  /** Multiplier on the default kernel bandwidth. Above 1 is smoother and less\n   *  committal; below 1 exposes the individual sections. */\n  densitySmoothing: number;\n  /**\n   * Draw the active GENE as a continuous field under the observations (2D).\n   *\n   * Colouring the markers by a gene says which cells express it; it cannot say\n   * where, because the eye will not integrate thousands of dots into a territory.\n   * The field is an estimate — a kernel-weighted mean per cell, transparent where\n   * no cell was measured — and it is drawn beneath the cells, not instead of them,\n   * so the measurement stays on screen next to the interpolation.\n   *\n   * Ignored unless the colour source is a gene: there is nothing else to map.\n   */\n  geneMap: boolean;\n  /**\n   * Restrict the 3D gene map to ONE imaged section, by index into the dataset's\n   * sampled sections; null draws every section's sheet.\n   *\n   * Separate from {@link pointSection} so the combinations stay open: all the\n   * sheets with one section's cells over them is a useful view, and so is one\n   * sheet inside the whole cloud. Ignored while {@link geneMapVolume} is set —\n   * interpolating a single section along z would smear one slide through the\n   * specimen's whole depth and call it an estimate.\n   */\n  geneMapSection: number | null;\n  /**\n   * Smooth the per-section gene maps along z into a continuous VOLUME (3D).\n   *\n   * The sheets are what was measured — one field per imaged slide, with the gaps\n   * between them empty. This turns them into an estimate defined between the\n   * slides, the same move the cluster density volumes make and with the same\n   * caveat: a field may be interpolated between sections, individual cells may\n   * not, and the result is drawn as a translucent cloud so it cannot be mistaken\n   * for measurement.\n   */\n  geneMapVolume: boolean;\n  /** Multiplier on the gene map's kernel bandwidth. */\n  geneMapSmoothing: number;\n  /** The gene map's own opacity. Separate from {@link opacity}, which belongs to\n   *  the markers: turning the cells down to read the field underneath must not\n   *  turn the field down with them. */\n  geneMapOpacity: number;\n}\n\nexport const DEFAULT_SPATIAL_VIEW: SpatialViewState = {\n  colorBy: null,\n  pointScale: 1,\n  opacity: 1,\n  logScale: false,\n  percentileClip: [0.01, 0.99],\n  continuousColormap: null,\n  showVolume: true,\n  volumeOpacity: 0.5,\n  showPoints: true,\n  pointSection: null,\n  densityVolume: false,\n  densitySmoothing: 1,\n  geneMap: false,\n  geneMapSection: null,\n  geneMapVolume: false,\n  geneMapSmoothing: 1,\n  geneMapOpacity: 0.85,\n};\n"]}

package/esm2022/lib/contracts/image.contract.mjs

@@ -8,4 +8,4 @@
  * structurally, so the host keeps passing its own instances unchanged.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/contracts/plot-type-contribution.contract.mjs

@@ -0,0 +1,66 @@
+/**
+ * How a plot mode gets into the plot-type selector without this library knowing
+ * what it is.
+ *
+ * A package contributes a mode by providing a {@link PlotTypeContribution} on the
+ * {@link PLOT_TYPE_CONTRIBUTIONS} multi-provider token, the same way
+ * `TOOLBAR_TOOLS` contributes toolbar tools. Nothing registers at import time:
+ * installing a package makes a mode available, and adding its provider turns it
+ * on. A plain object works, so the contributing package needs no Angular
+ * compiler and no decorators:
+ *
+ *     { provide: PLOT_TYPE_CONTRIBUTIONS, useValue: myContribution, multi: true }
+ *     { provide: PLOT_TYPE_CONTRIBUTIONS, useFactory: () => makeContribution(), multi: true }
+ *
+ * Provide nothing and the selector, the render path and the panel area behave
+ * exactly as they did before this extension point existed.
+ *
+ * WHY A CONTRIBUTED MODE RIDES ON A BUILT-IN ONE
+ * A contributed mode does not bring a renderer. It names a built-in
+ * {@link ContributedPlotTypeDescriptor.baseType} — in v1 only `PlotType.IMAGE`,
+ * the OpenSeadragon view — and the visualizer plots exactly as if that type had
+ * been selected: same backend, same toolbar, same region tools, same wheel
+ * handling. The contribution then draws over it through the
+ * {@link PlotModeViewport} and talks to the viewer through the public
+ * {@link IVisualizer}. That keeps every rendering decision in one place and means
+ * a contribution can never be half-supported by some code path that switches on
+ * the plot type.
+ *
+ * WHAT THE VISUALIZER GUARANTEES
+ *  1. Contributed descriptors are appended after the built-in ones and curated by
+ *     the same `productionLabel` / test-mode / `requires*` rules.
+ *  2. Selecting one plots with `baseType`'s backend, then calls `activate(ctx)`
+ *     once the viewport is ready.
+ *  3. Leaving the mode — another type, an image switch (or any re-render of the
+ *     base view), or the visualizer being destroyed — calls `session.deactivate()`
+ *     exactly once, before the next mode draws. If the mode is still selected
+ *     when the new image has plotted, a fresh session is activated for it.
+ *  4. `panel` is shown only while a session is live.
+ *  5. A thrown error or rejected promise from `activate`, `deactivate`, `mount`
+ *     or a mount's teardown is caught and logged; none escapes, so a contribution
+ *     cannot break the viewer. Failing to start (`activate`, `mount`, or a panel
+ *     component throwing while it is created / first rendered) falls back
+ *     to `baseType`. Failing to clean up falls back when that same mode is being
+ *     re-activated (base re-render, image switch) — immediately if it already is
+ *     live again — and is only logged when the user has moved to another mode; the
+ *     user explicitly selecting it again gets a fresh attempt.
+ *  6. {@link PLOT_TYPE_CONTRIBUTIONS} has no factory: no providers, no modes.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Multi-provider token for contributed plot modes.
+ *
+ * Deliberately has no `factory`: unregistered means no contributed modes, and the
+ * library behaves exactly as before. The visualizer injects it `{ optional: true }`
+ * and treats null as empty.
+ */
+export const PLOT_TYPE_CONTRIBUTIONS = new InjectionToken('PLOT_TYPE_CONTRIBUTIONS');
+/** The active mode's context, in a component panel's injector. */
+export const PLOT_MODE_CONTEXT = new InjectionToken('PLOT_MODE_CONTEXT');
+/** The active mode's session, in a component panel's injector. */
+export const PLOT_MODE_SESSION = new InjectionToken('PLOT_MODE_SESSION');
+/** The selector entry for a contributed mode, given its base type's descriptor. */
+export function contributedPlotTypeOption(d, base) {
+    return { ...d, source: base.source };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plot-type-contribution.contract.js","sourceRoot":"","sources":["../../../../src/lib/contracts/plot-type-contribution.contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,EAAE,cAAc,EAAQ,MAAM,eAAe,CAAC;AAsGrD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAClC,IAAI,cAAc,CAAkC,yBAAyB,CAAC,CAAC;AACjF,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAC1F,kEAAkE;AAClE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAa1F,mFAAmF;AACnF,MAAM,UAAU,yBAAyB,CACvC,CAAgC,EAChC,IAAwB;IAExB,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;AACvC,CAAC","sourcesContent":["/**\n * How a plot mode gets into the plot-type selector without this library knowing\n * what it is.\n *\n * A package contributes a mode by providing a {@link PlotTypeContribution} on the\n * {@link PLOT_TYPE_CONTRIBUTIONS} multi-provider token, the same way\n * `TOOLBAR_TOOLS` contributes toolbar tools. Nothing registers at import time:\n * installing a package makes a mode available, and adding its provider turns it\n * on. A plain object works, so the contributing package needs no Angular\n * compiler and no decorators:\n *\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useValue: myContribution, multi: true }\n *     { provide: PLOT_TYPE_CONTRIBUTIONS, useFactory: () => makeContribution(), multi: true }\n *\n * Provide nothing and the selector, the render path and the panel area behave\n * exactly as they did before this extension point existed.\n *\n * WHY A CONTRIBUTED MODE RIDES ON A BUILT-IN ONE\n * A contributed mode does not bring a renderer. It names a built-in\n * {@link ContributedPlotTypeDescriptor.baseType} — in v1 only `PlotType.IMAGE`,\n * the OpenSeadragon view — and the visualizer plots exactly as if that type had\n * been selected: same backend, same toolbar, same region tools, same wheel\n * handling. The contribution then draws over it through the\n * {@link PlotModeViewport} and talks to the viewer through the public\n * {@link IVisualizer}. That keeps every rendering decision in one place and means\n * a contribution can never be half-supported by some code path that switches on\n * the plot type.\n *\n * WHAT THE VISUALIZER GUARANTEES\n *  1. Contributed descriptors are appended after the built-in ones and curated by\n *     the same `productionLabel` / test-mode / `requires*` rules.\n *  2. Selecting one plots with `baseType`'s backend, then calls `activate(ctx)`\n *     once the viewport is ready.\n *  3. Leaving the mode — another type, an image switch (or any re-render of the\n *     base view), or the visualizer being destroyed — calls `session.deactivate()`\n *     exactly once, before the next mode draws. If the mode is still selected\n *     when the new image has plotted, a fresh session is activated for it.\n *  4. `panel` is shown only while a session is live.\n *  5. A thrown error or rejected promise from `activate`, `deactivate`, `mount`\n *     or a mount's teardown is caught and logged; none escapes, so a contribution\n *     cannot break the viewer. Failing to start (`activate`, `mount`, or a panel\n *     component throwing while it is created / first rendered) falls back\n *     to `baseType`. Failing to clean up falls back when that same mode is being\n *     re-activated (base re-render, image switch) — immediately if it already is\n *     live again — and is only logged when the user has moved to another mode; the\n *     user explicitly selecting it again gets a fresh attempt.\n *  6. {@link PLOT_TYPE_CONTRIBUTIONS} has no factory: no providers, no modes.\n */\nimport { InjectionToken, Type } from '@angular/core';\nimport type { Observable } from 'rxjs';\n\nimport type { IImageInfo } from './image.contract';\nimport type { PlotType, PlotTypeDescriptor, PlotTypeId } from './plot-type';\nimport type { IVisualizer } from './visualizer.contract';\n\n/** A rectangle in level-0 image pixels. */\nexport interface PlotModeRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Selector metadata for a contributed plot mode. */\nexport interface ContributedPlotTypeDescriptor {\n  /** Unique id, namespaced, e.g. 'dianne'. Must not clash with PlotType values. */\n  type: string;\n  /** Test-mode label, e.g. 'Digital Pathology - DIANNE'. */\n  label: string;\n  /** Default-selector label; omit to make the mode test-only (same rule as built-ins). */\n  productionLabel?: string;\n  /** 'pi pi-…' class or asset path, same as PlotTypeDescriptor.icon. */\n  icon?: string;\n  /** Always '2d' in v1. */\n  dimensions: '2d';\n  /** Built-in type whose backend renders the base image. v1 supports PlotType.IMAGE (OSD). */\n  baseType: PlotType;\n  /** Same gates as PlotTypeDescriptor, evaluated in addition to the base type's own. */\n  requiresGrayscale?: boolean;\n  requiresStack?: boolean;\n  /** Hidden until a `SpatialDataset` is published on SPATIAL_DATA_PORT (an overlay of spatial observations). */\n  requiresSpatialData?: boolean;\n  /** Hidden unless the published dataset carries `observations.z`. */\n  requiresSpatial3d?: boolean;\n}\n\n/** The base view's viewport, as a contributed mode sees it. */\nexport interface PlotModeViewport {\n  /** Element the mode's overlay canvas/SVG attaches to; fills the plot area. */\n  getOverlayContainer(): HTMLElement | null;\n  /** Level-0 image px -> client px, and the reverse. */\n  dataToClient(x: number, y: number): { x: number; y: number };\n  clientToData(clientX: number, clientY: number): { x: number; y: number };\n  /** Screen px per image px at the current zoom. */\n  dataLengthToScreen(len: number): number;\n  isReady(): boolean;\n  /** Visible image rect in level-0 px, emitted on every redraw frame (pan/zoom animation).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  frame$: Observable<PlotModeRect>;\n  /** Same rect, emitted once the viewport settles (existing getViewportChange$ semantics).\n   *  A new subscriber first receives the current rect when the viewport is ready. */\n  settled$: Observable<PlotModeRect>;\n}\n\n/** Everything a contributed mode gets to work with while it is active. */\nexport interface PlotModeContext {\n  /** Full public visualizer API: regions, region overlay (tool modes), undo, etc. */\n  visualizer: IVisualizer;\n  viewport: PlotModeViewport;\n  /** Current image info from IMAGE_STATE_PORT (null until an image is loaded). */\n  imageInfo$: Observable<IImageInfo | null>;\n}\n\n/** A live activation of a contributed mode. */\nexport interface PlotModeSession {\n  /** Called when the user leaves the mode, the image changes, or the visualizer is destroyed. */\n  deactivate(): void;\n}\n\n/**\n * The mode's side panel, shown in the visualizer's right-hand panel area while\n * a session is live. Two forms:\n *\n *  - `component`: an Angular component, rendered through `NgComponentOutlet`\n *    with {@link PLOT_MODE_CONTEXT} and {@link PLOT_MODE_SESSION} in its\n *    injector. Needs an AOT-compiled (partial-Ivy) component.\n *  - `mount`: framework-agnostic. The visualizer hands over an empty host\n *    element after `activate` resolves; the function renders into it and returns\n *    a teardown. The teardown is called exactly once when the mode deactivates,\n *    before `session.deactivate()`, and the host element is then removed.\n */\nexport type PlotModePanel =\n  | { title: string; component: Type<unknown> }\n  | {\n      title: string;\n      mount(host: HTMLElement, ctx: PlotModeContext, session: PlotModeSession): () => void;\n    };\n\n/** A plot mode contributed to the selector. A plain object is enough. */\nexport interface PlotTypeContribution {\n  descriptor: ContributedPlotTypeDescriptor;\n  /** Called after the base backend has plotted the image in this mode. */\n  activate(ctx: PlotModeContext): PlotModeSession | Promise<PlotModeSession>;\n  /**\n   * Optional side panel, rendered in the visualizer's right-hand panel area while the\n   * mode is active. A component panel can inject PLOT_MODE_CONTEXT and PLOT_MODE_SESSION.\n   */\n  panel?: PlotModePanel;\n}\n\n/**\n * Multi-provider token for contributed plot modes.\n *\n * Deliberately has no `factory`: unregistered means no contributed modes, and the\n * library behaves exactly as before. The visualizer injects it `{ optional: true }`\n * and treats null as empty.\n */\nexport const PLOT_TYPE_CONTRIBUTIONS =\n  new InjectionToken<readonly PlotTypeContribution[]>('PLOT_TYPE_CONTRIBUTIONS');\n/** The active mode's context, in a component panel's injector. */\nexport const PLOT_MODE_CONTEXT = new InjectionToken<PlotModeContext>('PLOT_MODE_CONTEXT');\n/** The active mode's session, in a component panel's injector. */\nexport const PLOT_MODE_SESSION = new InjectionToken<PlotModeSession>('PLOT_MODE_SESSION');\n\n/**\n * One entry in the plot-type selector: a built-in {@link PlotTypeDescriptor}\n * as-is, or a contributed descriptor completed with its base type's `source`.\n * Every entry therefore carries the same fields the selector curates by.\n */\nexport interface PlotTypeOption extends Omit<PlotTypeDescriptor, 'type'> {\n  type: PlotTypeId;\n  /** Set only for a contributed mode: the built-in type that renders it. */\n  baseType?: PlotType;\n}\n\n/** The selector entry for a contributed mode, given its base type's descriptor. */\nexport function contributedPlotTypeOption(\n  d: ContributedPlotTypeDescriptor,\n  base: PlotTypeDescriptor,\n): PlotTypeOption {\n  return { ...d, source: base.source };\n}\n"]}