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

package/lib/contracts/image.contract.d.ts

@@ -54,6 +54,12 @@ export interface IImageInfo {
      *  opposed to the scalar `roiJsonStr`, which is one ROI set for the whole
      *  image (a single file or a server z-stack). (jit-ui#93) */
     roiJsonStrs?: (string | null)[];
+    /** Per-slice, per-channel plane URLs for a SERVERLESS multichannel image
+     *  (`tiled: false` + `imageMeta[0].channelCount > 1`). `channelUrls[z][c]`
+     *  is a complete single-band image of channel c at slice z. The OSD simple
+     *  path composites them client-side — per-channel colour/window/gamma from
+     *  the channel pane — instead of opening the flat `urls[z]`. (jit-ui#76) */
+    channelUrls?: string[][];
     imageMeta: IImageMetadata[];
     /** How the OpenSeadragon backend should source this image.
      *  - `true`/absent (default): server-tiled — OSD polls `/tiles/info` for a

package/lib/implementations/osd/histogram-sampler.d.ts

@@ -74,6 +74,23 @@ export declare class HistogramSampler {
      * only). Fire-and-forget; failures leave the window unset (identity 0..255).
      */
     computeImageWindow(d: SampledDescriptor, infoB64: string, z: number): Promise<void>;
+    /**
+     * Client-side histogram for the SIMPLE (`tiled:false`) path: bin an
+     * already-decoded RGBA frame's OWN pixels — no tile server, no fetch. Same
+     * output shape as {@link computeImageWindow}: grayscale → [intensity];
+     * RGB → [R, G, B]. This is what lets the Channels & Histogram pane work for
+     * serverless images (the processing-pipeline preview, DICOM/TIFF stacks),
+     * which never hit the tile / `/histogram` endpoints.
+     */
+    computeSimpleHistogram(z: number, data: Uint8ClampedArray | Uint8Array, gray: boolean): void;
+    /**
+     * Per-channel histograms for a SIMPLE (`tiled:false`) MULTICHANNEL image: bin
+     * each already-decoded channel plane's own pixels (no tile server). One
+     * histogram per channel, so the pane's per-channel selector works serverlessly.
+     */
+    computeSimpleMultichannelHistograms(z: number, planes: Array<{
+        data: Uint8ClampedArray | Uint8Array;
+    }>): void;
     /**
      * Native-bit-depth histogram for >8-bit images, from the server `/histogram`
      * endpoint (the 8-bit canvas tiles can't carry 16-bit values). Cached per

package/lib/implementations/osd/openseadragon-visualizer.service.d.ts

@@ -123,6 +123,14 @@ export declare class OpenSeadragonVisualizerService extends BaseStoreVisualizer
     /** preview blob URL → full-res upscaled blob URL (see toFullResUrl), so
      *  re-visiting a simple-mode slice doesn't re-upscale. Revoked on file change. */
     private readonly simpleFullResUrls;
+    /** SERVERLESS multichannel (tiled:false + channelCount>1): the stack's
+     *  per-slice per-channel plane URLs, the current slice's decoded planes, and
+     *  the last composite blob URL. Composited client-side via display.channelRgbLut
+     *  (no tile server); kept OFF the tiled isMultiChannel path. */
+    private simpleMultichannel;
+    private simpleChannelUrls;
+    private simpleChannelPlanes;
+    private simpleCompositeUrl;
     /** Skip the full-res upscale above this longest-side dimension — a folder
      *  stack is per-file previews (well under this); this only guards against an
      *  accidental enormous canvas allocation. */
@@ -246,6 +254,23 @@ export declare class OpenSeadragonVisualizerService extends BaseStoreVisualizer
      * they're implausibly large (guards against an enormous canvas). (jit-ui#93)
      */
     private toFullResUrl;
+    /** Sample a SIMPLE-mode slice's own decoded pixels into the histogram — the
+     *  serverless analog of the tiled samplers (no tile server). Fire-and-forget;
+     *  a decode failure just leaves the pane empty rather than throwing. */
+    private sampleSimpleHistogram;
+    /** Fetch + decode a slice's per-channel planes (single-band grayscale) into
+     *  pixel buffers, for the SERVERLESS multichannel compositor. Auth-safe: goes
+     *  through SimpleSliceAccessService (blob:/data: as-is; http via HttpClient). */
+    private loadSimpleChannelPlanes;
+    /** Composite the cached per-channel planes into ONE RGBA image using the
+     *  current channel states (colour/window/gamma/visibility) — the client-side,
+     *  serverless analog of the tiled per-channel 'lighter' compositor
+     *  (same display.channelRgbLut math as recolorChannelTile, applied per-plane).
+     *  Returns a blob: URL of the composite PNG, revoking the previous one. */
+    private compositeSimpleMultichannel;
+    /** Re-composite the current slice from its cached planes (new channel states)
+     *  and re-open — the serverless analog of the tiled invalidate-on-channel-change. */
+    private recompositeAndOpen;
     /** Load a URL into an HTMLImageElement (resolves once decoded). Uses
      *  document.createElement rather than `new Image()` because this file's
      *  `Image` import is image-js's decoder, not the DOM element. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jax-data-science/sci-image-visualizer",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Browser-based scientific image visualization for Angular — gigapixel whole-slide (OpenSeadragon), 2D/3D (Plotly) and WebGPU (napari-js) rendering, with region/annotation editing and in-browser SAM segmentation.",
   "keywords": [
     "angular",