@knopkem/dicomview 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { DICOMwebLoader } from "./loader.js";
-export { Presets } from "./presets.js";
-export { ensureDicomviewWasm, Viewer } from "./viewer.js";
-export type { BlendMode, DICOMwebLoaderOptions, ProgressCallback, ProjectionMode, SeriesParams, ThickSlabOptions, ViewportId, ViewerOptions, VolumeGeometry, VolumePreset, WasmSource, } from "./types.js";
+export { CornerstonePresets, Presets } from "./presets.js";
+export { ensureDicomviewWasm, StackViewer, Viewer } from "./viewer.js";
+export { InputHandler, VolumeInputHandler } from "./input-handler.js";
+export type { BlendMode, DICOMwebLoaderOptions, InputTool, ProgressCallback, ProjectionMode, SeriesParams, StackViewerOptions, ThickSlabOptions, ViewportId, ViewerOptions, VolumeGeometry, VolumePreset, WasmSource, } from "./types.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { DICOMwebLoader } from "./loader.js";
-export { Presets } from "./presets.js";
-export { ensureDicomviewWasm, Viewer } from "./viewer.js";
+export { CornerstonePresets, Presets } from "./presets.js";
+export { ensureDicomviewWasm, StackViewer, Viewer } from "./viewer.js";
+export { InputHandler, VolumeInputHandler } from "./input-handler.js";

package/dist/input-handler.d.ts

@@ -0,0 +1,35 @@
+import type { InputTool, ViewportId } from "./types.js";
+import type { StackViewer, Viewer } from "./viewer.js";
+type ViewerLike = Viewer | StackViewer;
+/**
+ * Optional built-in input handler for slice viewports.
+ *
+ * Binds pointer and wheel events to a canvas and translates them into
+ * Viewer API calls based on the active tool. Supports left/middle/right
+ * mouse button differentiation:
+ * - **Left button**: active tool (windowLevel, pan, zoom, crosshair, scroll)
+ * - **Middle button**: pan
+ * - **Right button**: zoom
+ * - **Wheel**: scroll (shift+wheel → zoom)
+ */
+export declare class InputHandler {
+    #private;
+    constructor(canvas: HTMLCanvasElement, viewer: ViewerLike, viewport?: ViewportId);
+    get activeTool(): InputTool;
+    setActiveTool(tool: InputTool): void;
+    destroy(): void;
+}
+/**
+ * Input handler specialized for the 3D volume viewport.
+ *
+ * - **Left drag**: orbit (rotate camera)
+ * - **Middle drag**: pan
+ * - **Right drag**: zoom
+ * - **Wheel**: zoom
+ */
+export declare class VolumeInputHandler {
+    #private;
+    constructor(canvas: HTMLCanvasElement, viewer: Viewer);
+    destroy(): void;
+}
+export {};

package/dist/input-handler.js

@@ -0,0 +1,227 @@
+const WL_SENSITIVITY = 1.0;
+const PAN_SENSITIVITY = 1.0;
+const ZOOM_SENSITIVITY = 0.005;
+const SCROLL_SENSITIVITY = 1.0;
+function hasMethod(viewer, name) {
+    return typeof viewer[name] === "function";
+}
+/**
+ * Optional built-in input handler for slice viewports.
+ *
+ * Binds pointer and wheel events to a canvas and translates them into
+ * Viewer API calls based on the active tool. Supports left/middle/right
+ * mouse button differentiation:
+ * - **Left button**: active tool (windowLevel, pan, zoom, crosshair, scroll)
+ * - **Middle button**: pan
+ * - **Right button**: zoom
+ * - **Wheel**: scroll (shift+wheel → zoom)
+ */
+export class InputHandler {
+    #canvas;
+    #viewer;
+    #viewport;
+    #activeTool = "windowLevel";
+    #dragging = null;
+    #abortController = new AbortController();
+    #renderScheduled = false;
+    constructor(canvas, viewer, viewport = "axial") {
+        this.#canvas = canvas;
+        this.#viewer = viewer;
+        this.#viewport = viewport;
+        this.#bind();
+    }
+    get activeTool() {
+        return this.#activeTool;
+    }
+    setActiveTool(tool) {
+        this.#activeTool = tool;
+    }
+    destroy() {
+        this.#abortController.abort();
+        this.#dragging = null;
+    }
+    #bind() {
+        const signal = this.#abortController.signal;
+        const canvas = this.#canvas;
+        canvas.addEventListener("pointerdown", (e) => {
+            e.preventDefault();
+            canvas.setPointerCapture(e.pointerId);
+            this.#dragging = { startX: e.clientX, startY: e.clientY, button: e.button };
+        }, { signal });
+        canvas.addEventListener("pointermove", (e) => {
+            if (!this.#dragging)
+                return;
+            const dx = e.clientX - this.#dragging.startX;
+            const dy = e.clientY - this.#dragging.startY;
+            this.#dragging.startX = e.clientX;
+            this.#dragging.startY = e.clientY;
+            this.#handleDrag(dx, dy, this.#dragging.button);
+        }, { signal });
+        canvas.addEventListener("pointerup", (e) => {
+            canvas.releasePointerCapture(e.pointerId);
+            this.#dragging = null;
+        }, { signal });
+        canvas.addEventListener("pointercancel", (e) => {
+            canvas.releasePointerCapture(e.pointerId);
+            this.#dragging = null;
+        }, { signal });
+        canvas.addEventListener("wheel", (e) => {
+            e.preventDefault();
+            if (e.shiftKey) {
+                const factor = 1.0 - e.deltaY * ZOOM_SENSITIVITY;
+                if (hasMethod(this.#viewer, "zoom")) {
+                    this.#viewer.zoom(factor);
+                }
+            }
+            else {
+                const delta = (e.deltaY > 0 ? 1 : -1) * SCROLL_SENSITIVITY;
+                this.#scroll(delta);
+            }
+            this.#scheduleRender();
+        }, { signal, passive: false });
+        canvas.addEventListener("contextmenu", (e) => e.preventDefault(), { signal });
+    }
+    #handleDrag(dx, dy, button) {
+        if (button === 1) {
+            this.#pan(dx, dy);
+        }
+        else if (button === 2) {
+            const factor = 1.0 - dy * ZOOM_SENSITIVITY;
+            if (hasMethod(this.#viewer, "zoom")) {
+                this.#viewer.zoom(factor);
+            }
+        }
+        else {
+            this.#handleToolDrag(dx, dy);
+        }
+        this.#scheduleRender();
+    }
+    #handleToolDrag(dx, dy) {
+        switch (this.#activeTool) {
+            case "windowLevel": {
+                const viewer = this.#viewer;
+                // Approximate W/L adjustment — caller should maintain center/width state
+                // for proper behavior; this provides a reasonable default interaction.
+                viewer.setWindowLevel(dx * WL_SENSITIVITY, dy * WL_SENSITIVITY);
+                break;
+            }
+            case "pan":
+                this.#pan(dx, dy);
+                break;
+            case "zoom": {
+                const factor = 1.0 - dy * ZOOM_SENSITIVITY;
+                if (hasMethod(this.#viewer, "zoom")) {
+                    this.#viewer.zoom(factor);
+                }
+                break;
+            }
+            case "crosshair":
+                // Crosshair requires world-space conversion — viewer-specific, not handled here
+                break;
+            case "scroll":
+                this.#scroll(dy > 0 ? 1 : dy < 0 ? -1 : 0);
+                break;
+        }
+    }
+    #pan(dx, dy) {
+        if (hasMethod(this.#viewer, "pan")) {
+            this.#viewer.pan(dx * PAN_SENSITIVITY, dy * PAN_SENSITIVITY);
+        }
+    }
+    #scroll(delta) {
+        const viewer = this.#viewer;
+        if (hasMethod(viewer, "scrollSlice") && !hasMethod(viewer, "orbit")) {
+            // StackViewer: scrollSlice(delta)
+            viewer.scrollSlice(delta);
+        }
+        else if (hasMethod(viewer, "scrollSlice")) {
+            // Viewer: scrollSlice(viewport, delta)
+            viewer.scrollSlice(this.#viewport, delta);
+        }
+    }
+    #scheduleRender() {
+        if (this.#renderScheduled)
+            return;
+        this.#renderScheduled = true;
+        requestAnimationFrame(() => {
+            this.#renderScheduled = false;
+            this.#viewer.render();
+        });
+    }
+}
+/**
+ * Input handler specialized for the 3D volume viewport.
+ *
+ * - **Left drag**: orbit (rotate camera)
+ * - **Middle drag**: pan
+ * - **Right drag**: zoom
+ * - **Wheel**: zoom
+ */
+export class VolumeInputHandler {
+    #canvas;
+    #viewer;
+    #dragging = null;
+    #abortController = new AbortController();
+    #renderScheduled = false;
+    constructor(canvas, viewer) {
+        this.#canvas = canvas;
+        this.#viewer = viewer;
+        this.#bind();
+    }
+    destroy() {
+        this.#abortController.abort();
+        this.#dragging = null;
+    }
+    #bind() {
+        const signal = this.#abortController.signal;
+        const canvas = this.#canvas;
+        canvas.addEventListener("pointerdown", (e) => {
+            e.preventDefault();
+            canvas.setPointerCapture(e.pointerId);
+            this.#dragging = { startX: e.clientX, startY: e.clientY, button: e.button };
+        }, { signal });
+        canvas.addEventListener("pointermove", (e) => {
+            if (!this.#dragging)
+                return;
+            const dx = e.clientX - this.#dragging.startX;
+            const dy = e.clientY - this.#dragging.startY;
+            this.#dragging.startX = e.clientX;
+            this.#dragging.startY = e.clientY;
+            if (this.#dragging.button === 0) {
+                this.#viewer.orbit(dx, dy);
+            }
+            else if (this.#dragging.button === 1) {
+                this.#viewer.pan(dx * PAN_SENSITIVITY, dy * PAN_SENSITIVITY);
+            }
+            else if (this.#dragging.button === 2) {
+                const factor = 1.0 - dy * ZOOM_SENSITIVITY;
+                this.#viewer.zoom(factor);
+            }
+            this.#scheduleRender();
+        }, { signal });
+        canvas.addEventListener("pointerup", (e) => {
+            canvas.releasePointerCapture(e.pointerId);
+            this.#dragging = null;
+        }, { signal });
+        canvas.addEventListener("pointercancel", (e) => {
+            canvas.releasePointerCapture(e.pointerId);
+            this.#dragging = null;
+        }, { signal });
+        canvas.addEventListener("wheel", (e) => {
+            e.preventDefault();
+            const factor = 1.0 - e.deltaY * ZOOM_SENSITIVITY;
+            this.#viewer.zoom(factor);
+            this.#scheduleRender();
+        }, { signal, passive: false });
+        canvas.addEventListener("contextmenu", (e) => e.preventDefault(), { signal });
+    }
+    #scheduleRender() {
+        if (this.#renderScheduled)
+            return;
+        this.#renderScheduled = true;
+        requestAnimationFrame(() => {
+            this.#renderScheduled = false;
+            this.#viewer.render();
+        });
+    }
+}

package/dist/loader.d.ts

@@ -1,9 +1,9 @@
-import { Viewer } from "./viewer.js";
+import { StackViewer, Viewer } from "./viewer.js";
 import type { DICOMwebLoaderOptions, ProgressCallback, SeriesParams } from "./types.js";
 export declare class DICOMwebLoader {
     #private;
     constructor(options: DICOMwebLoaderOptions);
     onProgress(callback: ProgressCallback): void;
     abort(): void;
-    loadSeries(viewer: Viewer, params: SeriesParams): Promise<void>;
+    loadSeries(viewer: Viewer | StackViewer, params: SeriesParams): Promise<void>;
 }

package/dist/loader.js

@@ -17,6 +17,7 @@ export class DICOMwebLoader {
         this.#abortController = null;
     }
     async loadSeries(viewer, params) {
+        const renderDuringLoad = this.#options.renderDuringLoad !== false;
         const controller = new AbortController();
         this.#abortController = controller;
         const metadataUrl = [
@@ -37,7 +38,7 @@ export class DICOMwebLoader {
         let nextIndex = 0;
         let renderScheduled = false;
         const scheduleRender = () => {
-            if (renderScheduled) {
+            if (!renderDuringLoad || renderScheduled) {
                 return;
             }
             renderScheduled = true;

package/dist/presets.d.ts

@@ -7,3 +7,13 @@ export declare const Presets: {
     readonly MR_ANGIO: "mr-angio";
     readonly MR_T2_BRAIN: "mr-t2-brain";
 };
+/** Cornerstone3D-style preset name aliases. */
+export declare const CornerstonePresets: {
+    readonly "CT-Bone": "ct-bone";
+    readonly "CT-Soft-Tissue": "ct-soft-tissue";
+    readonly "CT-Lung": "ct-lung";
+    readonly "CT-MIP": "ct-mip";
+    readonly "MR-Default": "mr-default";
+    readonly "MR-Angio": "mr-angio";
+    readonly "MR-T2-Brain": "mr-t2-brain";
+};

package/dist/presets.js

@@ -7,3 +7,13 @@ export const Presets = {
     MR_ANGIO: "mr-angio",
     MR_T2_BRAIN: "mr-t2-brain",
 };
+/** Cornerstone3D-style preset name aliases. */
+export const CornerstonePresets = {
+    "CT-Bone": "ct-bone",
+    "CT-Soft-Tissue": "ct-soft-tissue",
+    "CT-Lung": "ct-lung",
+    "CT-MIP": "ct-mip",
+    "MR-Default": "mr-default",
+    "MR-Angio": "mr-angio",
+    "MR-T2-Brain": "mr-t2-brain",
+};

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type ViewportId = "axial" | "coronal" | "sagittal";
 export type BlendMode = "composite" | "mip" | "minip" | "average";
 export type ProjectionMode = "thin" | "mip" | "minip" | "average";
-export type VolumePreset = "ct-bone" | "ct-soft-tissue" | "ct-lung" | "ct-mip" | "mr-default" | "mr-angio" | "mr-t2-brain";
+export type VolumePreset = "ct-bone" | "ct-soft-tissue" | "ct-lung" | "ct-mip" | "mr-default" | "mr-angio" | "mr-t2-brain" | "CT-Bone" | "CT-Soft-Tissue" | "CT-Lung" | "CT-MIP" | "MR-Default" | "MR-Angio" | "MR-T2-Brain";
 export type WasmSource = string | URL | Request | Response;
 export interface VolumeGeometry {
     dimensions: [number, number, number];
@@ -37,6 +37,11 @@ export interface ThickSlabOptions {
     thickness: number;
     projection: ProjectionMode;
 }
+export interface StackViewerOptions {
+    canvas: HTMLCanvasElement;
+    wasmUrl?: WasmSource;
+}
+export type InputTool = "windowLevel" | "pan" | "zoom" | "crosshair" | "scroll";
 export interface SeriesParams {
     studyUid: string;
     seriesUid: string;
@@ -49,4 +54,6 @@ export interface DICOMwebLoaderOptions {
     concurrency?: number;
     decodeWorkers?: number;
     wasmUrl?: WasmSource;
+    /** When true (default), renders after each slice during loading. */
+    renderDuringLoad?: boolean;
 }

package/dist/viewer.d.ts

@@ -1,4 +1,4 @@
-import type { BlendMode, ThickSlabOptions, ViewerOptions, ViewportId, VolumeGeometry, VolumePreset, WasmSource } from "./types.js";
+import type { BlendMode, StackViewerOptions, ThickSlabOptions, ViewerOptions, ViewportId, VolumeGeometry, VolumePreset, WasmSource } from "./types.js";
 export declare function ensureDicomviewWasm(wasmUrl?: WasmSource): Promise<void>;
 export declare class Viewer {
     #private;
@@ -21,3 +21,25 @@ export declare class Viewer {
     reset(): void;
     destroy(): void;
 }
+/**
+ * Single-canvas viewer for 2D stack browsing.
+ *
+ * Unlike {@link Viewer} which requires 4 canvases (axial, coronal, sagittal,
+ * volume), this only needs one canvas element. It renders a single orthogonal
+ * slice that users can scroll through.
+ */
+export declare class StackViewer {
+    #private;
+    private constructor();
+    static create(options: StackViewerOptions): Promise<StackViewer>;
+    get loadingProgress(): number;
+    prepareVolume(geometry: VolumeGeometry): void;
+    feedDicomSlice(zIndex: number, bytes: ArrayBuffer | ArrayBufferView): void;
+    feedPixelSlice(zIndex: number, pixels: Int16Array | ArrayBuffer): void;
+    render(): void;
+    scrollSlice(delta: number): void;
+    setWindowLevel(center: number, width: number): void;
+    setSliceMode(viewport: ViewportId): void;
+    reset(): void;
+    destroy(): void;
+}

package/dist/viewer.js

@@ -1,4 +1,4 @@
-import initWasm, { Viewer as WasmViewer } from "../wasm/dicomview_wasm.js";
+import initWasm, { Viewer as WasmViewer, StackViewer as WasmStackViewer, } from "../wasm/dicomview_wasm.js";
 const VIEWPORT_CODE = {
     axial: 0,
     coronal: 1,
@@ -106,3 +106,61 @@ function toUint8Array(value) {
     }
     return new Uint8Array(value);
 }
+/**
+ * Single-canvas viewer for 2D stack browsing.
+ *
+ * Unlike {@link Viewer} which requires 4 canvases (axial, coronal, sagittal,
+ * volume), this only needs one canvas element. It renders a single orthogonal
+ * slice that users can scroll through.
+ */
+export class StackViewer {
+    #inner;
+    constructor(inner) {
+        this.#inner = inner;
+    }
+    static async create(options) {
+        await ensureDicomviewWasm(options.wasmUrl);
+        const inner = await WasmStackViewer.create({ canvas: options.canvas });
+        return new StackViewer(inner);
+    }
+    get loadingProgress() {
+        return this.#requireInner().loading_progress();
+    }
+    prepareVolume(geometry) {
+        this.#requireInner().prepare_volume(geometry);
+    }
+    feedDicomSlice(zIndex, bytes) {
+        this.#requireInner().feed_dicom_slice(zIndex, toUint8Array(bytes));
+    }
+    feedPixelSlice(zIndex, pixels) {
+        const data = pixels instanceof Int16Array ? pixels : new Int16Array(pixels);
+        this.#requireInner().feed_pixel_slice(zIndex, data);
+    }
+    render() {
+        this.#requireInner().render();
+    }
+    scrollSlice(delta) {
+        this.#requireInner().scroll_slice(delta);
+    }
+    setWindowLevel(center, width) {
+        this.#requireInner().set_window_level(center, width);
+    }
+    setSliceMode(viewport) {
+        this.#requireInner().set_slice_mode(VIEWPORT_CODE[viewport]);
+    }
+    reset() {
+        this.#requireInner().reset();
+    }
+    destroy() {
+        if (this.#inner) {
+            this.#inner.destroy();
+            this.#inner = null;
+        }
+    }
+    #requireInner() {
+        if (!this.#inner) {
+            throw new Error("StackViewer has already been destroyed");
+        }
+        return this.#inner;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knopkem/dicomview",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Rust/WASM medical imaging primitives for the web",
   "type": "module",
   "sideEffects": false,

package/wasm/dicomview_wasm.d.ts

@@ -1,6 +1,61 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * A single-canvas viewer for 2D stack browsing (like cornerstone's `StackViewport`).
+ *
+ * Unlike [`Viewer`] which requires 4 canvases, this only needs one.
+ */
+export class StackViewer {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a new stack viewer bound to a single canvas element.
+     */
+    static create(config: any): Promise<StackViewer>;
+    /**
+     * Explicitly destroys the stack viewer and releases its resources.
+     */
+    destroy(): void;
+    /**
+     * Decodes one DICOM Part 10 payload and uploads its frame data.
+     */
+    feed_dicom_slice(z_index: number, bytes: Uint8Array): void;
+    /**
+     * Uploads one already-decoded signed 16-bit slice.
+     */
+    feed_pixel_slice(z_index: number, pixels: Int16Array): void;
+    /**
+     * Returns the current loading progress in `[0, 1]`.
+     */
+    loading_progress(): number;
+    /**
+     * Prepares an empty volume with the provided geometry object.
+     */
+    prepare_volume(geometry: any): void;
+    /**
+     * Renders the single slice canvas.
+     */
+    render(): void;
+    /**
+     * Resets all viewport state back to defaults.
+     */
+    reset(): void;
+    /**
+     * Scrolls the slice along its normal.
+     */
+    scroll_slice(delta: number): void;
+    /**
+     * Switches which orthogonal plane is displayed.
+     */
+    set_slice_mode(viewport: number): void;
+    /**
+     * Applies one window/level setting to the viewport.
+     */
+    set_window_level(center: number, width: number): void;
+}
+
 /**
  * One JS-visible viewer instance managing four canvases.
  */
@@ -120,7 +175,19 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_stackviewer_free: (a: number, b: number) => void;
     readonly __wbg_viewer_free: (a: number, b: number) => void;
+    readonly stackviewer_create: (a: any) => any;
+    readonly stackviewer_destroy: (a: number) => void;
+    readonly stackviewer_feed_dicom_slice: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly stackviewer_feed_pixel_slice: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly stackviewer_loading_progress: (a: number) => number;
+    readonly stackviewer_prepare_volume: (a: number, b: any) => [number, number];
+    readonly stackviewer_render: (a: number) => [number, number];
+    readonly stackviewer_reset: (a: number) => [number, number];
+    readonly stackviewer_scroll_slice: (a: number, b: number) => [number, number];
+    readonly stackviewer_set_slice_mode: (a: number, b: number) => [number, number];
+    readonly stackviewer_set_window_level: (a: number, b: number, c: number) => [number, number];
     readonly viewer_create: (a: any) => any;
     readonly viewer_destroy: (a: number) => void;
     readonly viewer_feed_dicom_slice: (a: number, b: number, c: number, d: number) => [number, number];

package/wasm/dicomview_wasm.js

@@ -1,5 +1,140 @@
 /* @ts-self-types="./dicomview_wasm.d.ts" */
 
+/**
+ * A single-canvas viewer for 2D stack browsing (like cornerstone's `StackViewport`).
+ *
+ * Unlike [`Viewer`] which requires 4 canvases, this only needs one.
+ */
+export class StackViewer {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StackViewer.prototype);
+        obj.__wbg_ptr = ptr;
+        StackViewerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StackViewerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stackviewer_free(ptr, 0);
+    }
+    /**
+     * Creates a new stack viewer bound to a single canvas element.
+     * @param {any} config
+     * @returns {Promise<StackViewer>}
+     */
+    static create(config) {
+        const ret = wasm.stackviewer_create(config);
+        return ret;
+    }
+    /**
+     * Explicitly destroys the stack viewer and releases its resources.
+     */
+    destroy() {
+        const ptr = this.__destroy_into_raw();
+        wasm.stackviewer_destroy(ptr);
+    }
+    /**
+     * Decodes one DICOM Part 10 payload and uploads its frame data.
+     * @param {number} z_index
+     * @param {Uint8Array} bytes
+     */
+    feed_dicom_slice(z_index, bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stackviewer_feed_dicom_slice(this.__wbg_ptr, z_index, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Uploads one already-decoded signed 16-bit slice.
+     * @param {number} z_index
+     * @param {Int16Array} pixels
+     */
+    feed_pixel_slice(z_index, pixels) {
+        const ptr0 = passArray16ToWasm0(pixels, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.stackviewer_feed_pixel_slice(this.__wbg_ptr, z_index, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Returns the current loading progress in `[0, 1]`.
+     * @returns {number}
+     */
+    loading_progress() {
+        const ret = wasm.stackviewer_loading_progress(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Prepares an empty volume with the provided geometry object.
+     * @param {any} geometry
+     */
+    prepare_volume(geometry) {
+        const ret = wasm.stackviewer_prepare_volume(this.__wbg_ptr, geometry);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Renders the single slice canvas.
+     */
+    render() {
+        const ret = wasm.stackviewer_render(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Resets all viewport state back to defaults.
+     */
+    reset() {
+        const ret = wasm.stackviewer_reset(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Scrolls the slice along its normal.
+     * @param {number} delta
+     */
+    scroll_slice(delta) {
+        const ret = wasm.stackviewer_scroll_slice(this.__wbg_ptr, delta);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Switches which orthogonal plane is displayed.
+     * @param {number} viewport
+     */
+    set_slice_mode(viewport) {
+        const ret = wasm.stackviewer_set_slice_mode(this.__wbg_ptr, viewport);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Applies one window/level setting to the viewport.
+     * @param {number} center
+     * @param {number} width
+     */
+    set_window_level(center, width) {
+        const ret = wasm.stackviewer_set_window_level(this.__wbg_ptr, center, width);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) StackViewer.prototype[Symbol.dispose] = StackViewer.prototype.free;
+
 /**
  * One JS-visible viewer instance managing four canvases.
  */
@@ -1185,6 +1320,10 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg_stackviewer_new: function(arg0) {
+            const ret = StackViewer.__wrap(arg0);
+            return ret;
+        },
         __wbg_static_accessor_GLOBAL_THIS_a1248013d790bf5f: function() {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1235,12 +1374,12 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 172, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 177, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h4c19ef90e3a2449e);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 690, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 695, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h77f088fde8c66f5c);
             return ret;
         },
@@ -1362,6 +1501,9 @@ const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
 
 
 const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+const StackViewerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stackviewer_free(ptr >>> 0, 1));
 const ViewerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_viewer_free(ptr >>> 0, 1));

package/wasm/dicomview_wasm_bg.wasm.d.ts

@@ -1,7 +1,19 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_stackviewer_free: (a: number, b: number) => void;
 export const __wbg_viewer_free: (a: number, b: number) => void;
+export const stackviewer_create: (a: any) => any;
+export const stackviewer_destroy: (a: number) => void;
+export const stackviewer_feed_dicom_slice: (a: number, b: number, c: number, d: number) => [number, number];
+export const stackviewer_feed_pixel_slice: (a: number, b: number, c: number, d: number) => [number, number];
+export const stackviewer_loading_progress: (a: number) => number;
+export const stackviewer_prepare_volume: (a: number, b: any) => [number, number];
+export const stackviewer_render: (a: number) => [number, number];
+export const stackviewer_reset: (a: number) => [number, number];
+export const stackviewer_scroll_slice: (a: number, b: number) => [number, number];
+export const stackviewer_set_slice_mode: (a: number, b: number) => [number, number];
+export const stackviewer_set_window_level: (a: number, b: number, c: number) => [number, number];
 export const viewer_create: (a: any) => any;
 export const viewer_destroy: (a: number) => void;
 export const viewer_feed_dicom_slice: (a: number, b: number, c: number, d: number) => [number, number];