@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/WSI/WSIViewport.js

@@ -0,0 +1,392 @@
+import { ViewportType } from '../../../enums';
+import GenericViewport from '../GenericViewport';
+import { DefaultWSIDataProvider } from './DefaultWSIDataProvider';
+import { createWSIRenderPathResolver } from './WSIRenderPathResolver';
+import { buildWSIColorTransform, buildWSIImageData, computeWSITransforms, indexToWorldWSIMetadata, worldToIndexWSIMetadata, } from './wsiTransformUtils';
+import WSIResolvedView from './WSIResolvedView';
+export default class WSIViewport extends GenericViewport {
+    static get useCustomRenderingPipeline() {
+        return true;
+    }
+    getUseCustomRenderingPipeline() {
+        return true;
+    }
+    constructor(args) {
+        super(args);
+        this.type = ViewportType.WHOLE_SLIDE_NEXT;
+        this.modality = 'SM';
+        this.renderingEngineId = args.renderingEngineId;
+        this.element.style.position = this.element.style.position || 'relative';
+        this.element.style.overflow = 'hidden';
+        this.element.style.background = this.element.style.background || '#000';
+        this.dataProvider = args.dataProvider || new DefaultWSIDataProvider();
+        this.renderPathResolver =
+            args.renderPathResolver || createWSIRenderPathResolver();
+        this.renderContext = {
+            viewportId: this.id,
+            renderingEngineId: this.renderingEngineId,
+            type: 'wsi',
+            element: this.element,
+        };
+        this.viewState = {
+            zoom: 1,
+            rotation: 0,
+        };
+        this.element.setAttribute('data-viewport-uid', this.id);
+        this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
+    }
+    normalizeViewState(camera) {
+        return {
+            ...camera,
+            zoom: Math.max(camera.zoom ?? 1, 0.001),
+            centerIndex: camera.centerIndex
+                ? [camera.centerIndex[0], camera.centerIndex[1]]
+                : camera.centerIndex,
+            resolution: typeof camera.resolution === 'number'
+                ? Math.max(camera.resolution, 0.000001)
+                : camera.resolution,
+            rotation: camera.rotation ?? 0,
+        };
+    }
+    async setDisplaySets(...entries) {
+        this.removeAllData();
+        for (const [index, { displaySetId }] of entries.entries()) {
+            await this.addDisplaySet(displaySetId, {
+                renderMode: 'wsi2d',
+                role: index === 0 ? 'source' : 'overlay',
+            });
+            this.setDefaultDataPresentation(displaySetId, {
+                visible: true,
+                opacity: 1,
+            });
+            this.activeDataId = displaySetId;
+        }
+        this.syncCameraFromView();
+        this.applyVOIToRendering();
+    }
+    setDisplaySetPresentation(displaySetIdOrProps, maybeProps) {
+        if (typeof displaySetIdOrProps === 'string') {
+            super.setDisplaySetPresentation(displaySetIdOrProps, maybeProps ?? {});
+            if (displaySetIdOrProps === this.getActiveDataId()) {
+                this.applyVOIToRendering();
+            }
+            return;
+        }
+        super.setDisplaySetPresentation(displaySetIdOrProps);
+        if (this.getActiveDataId()) {
+            this.applyVOIToRendering();
+        }
+    }
+    computeTransforms() {
+        return computeWSITransforms(this.getWSIData()?.metadata);
+    }
+    getImageData() {
+        const data = this.getWSIData();
+        return buildWSIImageData({
+            metadata: data?.metadata,
+            modality: this.modality,
+            frameOfReferenceUID: data?.frameOfReferenceUID,
+        });
+    }
+    hasImageURI(imageURI) {
+        if (!imageURI) {
+            return false;
+        }
+        return this.getWSIData()?.imageURISet.has(imageURI) || false;
+    }
+    setViewState(cameraPatch) {
+        this.syncCameraFromView();
+        const view = this.getView();
+        if (!view) {
+            super.setViewState(cameraPatch);
+            return;
+        }
+        const nextPatch = {};
+        if (typeof cameraPatch.zoom === 'number') {
+            nextPatch.zoom = Math.max(cameraPatch.zoom, 0.001);
+        }
+        if (cameraPatch.centerIndex) {
+            nextPatch.centerIndex = [
+                cameraPatch.centerIndex[0],
+                cameraPatch.centerIndex[1],
+            ];
+        }
+        if (typeof cameraPatch.rotation === 'number') {
+            nextPatch.rotation = cameraPatch.rotation;
+        }
+        if (typeof cameraPatch.resolution === 'number') {
+            nextPatch.resolution = Math.max(cameraPatch.resolution, 0.000001);
+        }
+        super.setViewState(nextPatch);
+    }
+    getResolvedView() {
+        const view = this.getView();
+        const data = this.getWSIData();
+        if (!view || !data) {
+            return;
+        }
+        return new WSIResolvedView({
+            viewState: this.viewState,
+            canvasHeight: this.element.clientHeight,
+            canvasWidth: this.element.clientWidth,
+            frameOfReferenceUID: data.frameOfReferenceUID,
+            metadata: data.metadata,
+            view,
+        });
+    }
+    getCurrentImageId() {
+        return this.getWSIData()?.imageIds[0];
+    }
+    getViewReference(_specifier = {}) {
+        const dataId = this.getCurrentBinding()?.data.id;
+        return {
+            FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            dataId,
+            referencedImageId: this.getCurrentImageId(),
+            sliceIndex: 0,
+        };
+    }
+    setViewReference(_viewRef) {
+    }
+    getFrameNumber() {
+        return 1;
+    }
+    async setFrameNumber(_frameNumber) {
+    }
+    resetViewState() {
+        return true;
+    }
+    getNumberOfSlices() {
+        return 1;
+    }
+    resize() {
+        if (this.isDestroyed) {
+            return;
+        }
+        this.resizeBindings();
+        this.render();
+    }
+    worldToIndexWSI(point) {
+        const rendering = this.getWSIRendering();
+        const affine = rendering?.viewer.getAffine();
+        const transformUtils = rendering?.transformUtils;
+        if (!transformUtils || !affine) {
+            throw new Error(`[WSIViewport] Cannot convert world to index for viewport ${this.id} because the WSI transform runtime is not ready.`);
+        }
+        const pixelCoords = transformUtils.applyInverseTransform({
+            coordinate: [point[0], point[1]],
+            affine,
+        });
+        return [pixelCoords[0], pixelCoords[1]];
+    }
+    indexToWorldWSI(point) {
+        const rendering = this.getWSIRendering();
+        const affine = rendering?.viewer.getAffine();
+        const transformUtils = rendering?.transformUtils;
+        if (!transformUtils || !affine) {
+            throw new Error(`[WSIViewport] Cannot convert index to world for viewport ${this.id} because the WSI transform runtime is not ready.`);
+        }
+        const sliceCoords = transformUtils.applyTransform({
+            coordinate: [point[0], point[1]],
+            affine,
+        });
+        return [sliceCoords[0], sliceCoords[1], 0];
+    }
+    worldToIndex(point) {
+        return worldToIndexWSIMetadata(this.getWSIData()?.metadata, point);
+    }
+    indexToWorld(point) {
+        return indexToWorldWSIMetadata(this.getWSIData()?.metadata, point);
+    }
+    scroll(delta) {
+        const resolution = this.getView()?.getResolution?.() ?? this.viewState.resolution ?? 1;
+        this.setViewState({
+            resolution: Math.max(resolution * (1 + 0.1 * delta), 0.000001),
+        });
+    }
+    getRotation() {
+        return 0;
+    }
+    getSliceIndex() {
+        return 0;
+    }
+    getView() {
+        const rendering = this.getWSIRendering();
+        const view = rendering?.map.getView();
+        if (!view || typeof window === 'undefined') {
+            return view;
+        }
+        const anyWindow = window;
+        anyWindow.map = rendering?.map;
+        anyWindow.viewer = rendering?.viewer;
+        anyWindow.view = view;
+        anyWindow.wsi = this;
+        return view;
+    }
+    getZoom() {
+        return Math.max(this.getView()?.getZoom?.() ?? this.viewState.zoom ?? 1, 0.001);
+    }
+    setZoom(zoom, canvasPoint) {
+        const resolvedView = this.getResolvedView();
+        if (resolvedView) {
+            this.applyResolvedViewState(resolvedView.withZoom(zoom, canvasPoint).state.viewState);
+            return;
+        }
+        this.setViewState({
+            zoom: Math.max(zoom, 0.001),
+        });
+    }
+    getImageIds() {
+        const imageId = this.getCurrentImageId();
+        return imageId ? [imageId] : [];
+    }
+    getViewReferenceId(_specifier = {}) {
+        return `imageId:${this.getCurrentImageId()}`;
+    }
+    getCurrentImageIdIndex() {
+        return 0;
+    }
+    applyResolvedViewState(nextViewState) {
+        this.setViewState(nextViewState);
+    }
+    render() {
+        if (this.isDestroyed) {
+            return;
+        }
+        this.renderBindings();
+    }
+    destroy() {
+        if (this.isDestroyed) {
+            return;
+        }
+        const rendering = this.getWSIRendering();
+        const map = rendering?.map;
+        const viewer = rendering?.viewer;
+        const view = map?.getView?.();
+        super.destroy();
+        this.clearGlobalDebugRefs({ map, viewer, view });
+    }
+    onDestroy() {
+        this.activeDataId = undefined;
+    }
+    customRenderViewportToCanvas() {
+        this.render();
+    }
+    setRendered() {
+    }
+    removeData(dataId) {
+        super.removeData(dataId);
+        if (this.activeDataId === dataId) {
+            this.activeDataId = this.bindings.keys().next().value;
+            this.applyVOIToRendering();
+        }
+    }
+    getCurrentBinding() {
+        return ((this.activeDataId ? this.getBinding(this.activeDataId) : undefined) ??
+            this.getFirstBinding());
+    }
+    getActiveDataId() {
+        return this.activeDataId;
+    }
+    getReferenceViewContexts() {
+        const binding = this.getCurrentBinding();
+        const data = this.getWSIData();
+        if (!binding || !data) {
+            return super.getReferenceViewContexts();
+        }
+        return [
+            {
+                dataId: binding.data.id,
+                dataIds: [binding.data.id],
+                frameOfReferenceUID: data.frameOfReferenceUID ?? undefined,
+                imageIds: data.imageIds,
+                imageURIs: Array.from(data.imageURISet),
+                allowAnyImageReference: true,
+                currentImageIdIndex: 0,
+            },
+        ];
+    }
+    applyVOIToRendering() {
+        const activeDataId = this.getActiveDataId();
+        const dataPresentation = activeDataId
+            ? this.getDisplaySetPresentation(activeDataId)
+            : undefined;
+        const filter = buildWSIColorTransform(dataPresentation?.voiRange || {
+            lower: 0,
+            upper: 255,
+        }, dataPresentation?.averageWhite);
+        const viewport = this.getMap()?.getViewport();
+        if (!viewport) {
+            return;
+        }
+        viewport.querySelectorAll('.ol-layers canvas').forEach((canvas) => {
+            canvas.style.filter = filter || '';
+        });
+    }
+    syncCameraFromView() {
+        const view = this.getView();
+        if (!view) {
+            return;
+        }
+        const centerIndex = view.getCenter();
+        this.viewState = this.normalizeViewState({
+            ...this.viewState,
+            zoom: view.getZoom(),
+            rotation: view.getRotation(),
+            resolution: view.getResolution(),
+            centerIndex: centerIndex ? [centerIndex[0], centerIndex[1]] : undefined,
+        });
+    }
+    getMap() {
+        return this.getWSIRendering()?.map;
+    }
+    getWSIData() {
+        const binding = this.getCurrentBinding();
+        if (!binding || !isWSIPayload(binding.data)) {
+            return;
+        }
+        return binding.data;
+    }
+    getWSIRendering() {
+        const binding = this.getCurrentBinding();
+        if (!binding || !isWSIRendering(binding.rendering)) {
+            return;
+        }
+        return binding.rendering;
+    }
+    clearGlobalDebugRefs(args) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const anyWindow = window;
+        if (anyWindow.wsi !== this) {
+            return;
+        }
+        if (args.map && anyWindow.map === args.map) {
+            delete anyWindow.map;
+        }
+        if (args.viewer && anyWindow.viewer === args.viewer) {
+            delete anyWindow.viewer;
+        }
+        if (args.view && anyWindow.view === args.view) {
+            delete anyWindow.view;
+        }
+        delete anyWindow.wsi;
+    }
+}
+function isWSIPayload(data) {
+    if (typeof data !== 'object' || data === null || data.type !== 'wsi') {
+        return false;
+    }
+    const payload = data;
+    return (Array.isArray(payload.imageIds) &&
+        typeof payload.client === 'object' &&
+        payload.client !== null &&
+        typeof payload.metadata === 'object' &&
+        payload.metadata !== null &&
+        typeof payload.frameOfReferenceUID !== 'undefined' &&
+        payload.imageURISet instanceof Set);
+}
+function isWSIRendering(rendering) {
+    return rendering.renderMode === 'wsi2d';
+}

package/dist/esm/RenderingEngine/GenericViewport/WSI/WSIViewportLegacyAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { ICamera, ImageSetOptions, VOIRange, ViewPresentation, ViewPresentationSelector, WSIViewportProperties } from '../../../types';
+import type { WSIClientLike } from '../../../utilities/WSIUtilities';
+import WSIViewport from './WSIViewport';
+import type { WSICamera, WSIViewState } from './WSIViewportTypes';
+declare class WSIViewportLegacyAdapter extends WSIViewport {
+    setCamera(cameraPatch: Partial<WSICamera>): void;
+    getCamera(): WSIViewState & ICamera;
+    setDataIds(imageIds: string[], options?: ImageSetOptions & {
+        miniNavigationOverlay?: boolean;
+        webClient?: WSIClientLike;
+    }): Promise<void>;
+    setWSI(imageIds: string[], client: WSIClientLike): Promise<void>;
+    setProperties(props: WSIViewportProperties): void;
+    getProperties(): WSIViewportProperties;
+    resetProperties(): void;
+    getViewPresentation(selector?: ViewPresentationSelector): ViewPresentation | undefined;
+    setViewPresentation(viewPres?: ViewPresentation): void;
+    resetCamera(): boolean;
+    setVOI(voiRange: VOIRange): void;
+    setAverageWhite(averageWhite: [number, number, number]): void;
+}
+export default WSIViewportLegacyAdapter;

package/dist/esm/RenderingEngine/GenericViewport/WSI/WSIViewportLegacyAdapter.js

@@ -0,0 +1,144 @@
+import { MetadataModules } from '../../../enums';
+import * as metaData from '../../../metaData';
+import genericViewportDataSetMetadataProvider from '../../../utilities/genericViewportDataSetMetadataProvider';
+import { viewportProjection } from '../viewportProjection';
+import { canvasToIndexForWSI } from './wsiTransformUtils';
+import WSIViewport from './WSIViewport';
+class WSIViewportLegacyAdapter extends WSIViewport {
+    setCamera(cameraPatch) {
+        const viewStatePatch = {};
+        if (typeof cameraPatch.zoom === 'number') {
+            viewStatePatch.zoom = cameraPatch.zoom;
+        }
+        if (cameraPatch.centerIndex) {
+            viewStatePatch.centerIndex = [
+                cameraPatch.centerIndex[0],
+                cameraPatch.centerIndex[1],
+            ];
+        }
+        if (typeof cameraPatch.rotation === 'number') {
+            viewStatePatch.rotation = cameraPatch.rotation;
+        }
+        if (typeof cameraPatch.resolution === 'number') {
+            viewStatePatch.resolution = cameraPatch.resolution;
+        }
+        if (typeof cameraPatch.parallelScale === 'number') {
+            const spacing = this.getImageData()?.spacing?.[0];
+            if (typeof spacing === 'number' && spacing > 0) {
+                const worldToCanvasRatio = this.element.clientHeight /
+                    Math.max(cameraPatch.parallelScale, 0.001);
+                viewStatePatch.resolution = 1 / spacing / worldToCanvasRatio;
+            }
+        }
+        if (cameraPatch.focalPoint) {
+            const view = this.getView();
+            if (view) {
+                const newCanvas = this.worldToCanvas(cameraPatch.focalPoint);
+                const newIndex = canvasToIndexForWSI({
+                    canvasPos: newCanvas,
+                    canvasWidth: this.element.clientWidth,
+                    canvasHeight: this.element.clientHeight,
+                    view,
+                });
+                viewStatePatch.centerIndex = [newIndex[0], newIndex[1]];
+            }
+        }
+        if (Object.keys(viewStatePatch).length) {
+            this.setViewState(viewStatePatch);
+        }
+    }
+    getCamera() {
+        return {
+            ...this.getViewState(),
+            ...this.getCameraForEvent(),
+        };
+    }
+    setDataIds(imageIds, options) {
+        const dataId = imageIds[0];
+        if (!dataId) {
+            return;
+        }
+        const webClient = options?.webClient ||
+            metaData.get(MetadataModules.WADO_WEB_CLIENT, dataId);
+        if (!webClient) {
+            throw new Error(`To use setDataIds on WSI data, you must provide metaData.webClient for ${dataId}.`);
+        }
+        genericViewportDataSetMetadataProvider.add(dataId, {
+            imageIds,
+            kind: 'wsi',
+            options: {
+                miniNavigationOverlay: options?.miniNavigationOverlay,
+                webClient,
+            },
+        });
+        return this.setDisplaySets({ displaySetId: dataId });
+    }
+    async setWSI(imageIds, client) {
+        return this.setDataIds(imageIds, {
+            webClient: client,
+        });
+    }
+    setProperties(props) {
+        const dataId = this.getActiveDataId();
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            voiRange: props.voiRange,
+        });
+    }
+    getProperties() {
+        const dataId = this.getActiveDataId();
+        const dataPresentation = dataId
+            ? this.getDisplaySetPresentation(dataId)
+            : undefined;
+        return {
+            voiRange: dataPresentation?.voiRange,
+        };
+    }
+    resetProperties() {
+        const dataId = this.getActiveDataId();
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            averageWhite: undefined,
+            voiRange: {
+                lower: 0,
+                upper: 255,
+            },
+        });
+    }
+    getViewPresentation(selector) {
+        return viewportProjection.getPresentation(this, {
+            selector,
+        });
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        const nextViewState = viewportProjection.withPresentation(this, viewPres);
+        if (nextViewState) {
+            this.setViewState(nextViewState);
+        }
+    }
+    resetCamera() {
+        return this.resetViewState();
+    }
+    setVOI(voiRange) {
+        const dataId = this.getActiveDataId();
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, { voiRange });
+    }
+    setAverageWhite(averageWhite) {
+        const dataId = this.getActiveDataId();
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, { averageWhite });
+    }
+}
+export default WSIViewportLegacyAdapter;

package/dist/esm/RenderingEngine/GenericViewport/WSI/WSIViewportTypes.d.ts

@@ -0,0 +1,58 @@
+import type { BaseViewportRenderContext, BasePresentationProps, DataProvider, LoadedData, MountedRendering, RenderPathResolver } from '../ViewportArchitectureTypes';
+import type { ViewportCameraBase } from '../ViewportCameraTypes';
+import type { WSIClientLike, WSIImageDataMetadata, WSIImageMetadataSource, WSIImageVolumeLike, WSIMapLike, WSITransformUtilitiesLike, WSIViewerLike } from '../../../utilities/WSIUtilities';
+import type ICamera from '../../../types/ICamera';
+import type { VOIRange } from '../../../types';
+export interface WSIDataSetOptions {
+    miniNavigationOverlay?: boolean;
+    webClient: WSIClientLike;
+}
+export interface WSIRegisteredDataSet {
+    imageIds: string[];
+    options: WSIDataSetOptions;
+}
+export interface WSIPayload {
+    imageIds: string[];
+    client: WSIClientLike;
+    volumeImages: WSIImageVolumeLike[];
+    metadataDicomweb: WSIImageMetadataSource[];
+    metadata: WSIImageDataMetadata;
+    frameOfReferenceUID: string | null;
+    imageURISet: Set<string>;
+}
+export interface WSIPresentationProps extends BasePresentationProps {
+}
+export interface WSIViewState extends ViewportCameraBase<[number, number]> {
+    centerIndex?: [number, number];
+    resolution?: number;
+    zoom?: number;
+}
+export type WSICamera = WSIViewState & ICamera;
+export interface WSIProperties {
+    voiRange?: VOIRange;
+    averageWhite?: [number, number, number];
+}
+export type WSIDataPresentation = WSIPresentationProps & WSIProperties;
+export interface WSIDataProvider extends DataProvider {
+    load(dataId: string): Promise<LoadedData<WSIPayload>>;
+}
+export interface WSIViewportInput {
+    id: string;
+    element: HTMLDivElement;
+    renderingEngineId: string;
+    dataProvider?: DataProvider;
+    renderPathResolver?: RenderPathResolver;
+}
+export type WSIGenericViewportInput = WSIViewportInput;
+export interface WSIViewportRenderContext extends BaseViewportRenderContext {
+    type: 'wsi';
+    element: HTMLDivElement;
+}
+export type WSIRendering = MountedRendering<{
+    renderMode: 'wsi2d';
+    microscopyElement: HTMLDivElement;
+    viewer: WSIViewerLike;
+    map: WSIMapLike;
+    transformUtils?: WSITransformUtilitiesLike;
+    postrenderHandler: () => void;
+}>;

package/dist/esm/RenderingEngine/GenericViewport/WSI/index.d.ts

@@ -0,0 +1,10 @@
+import { getWSIProjectionSnapshot } from './wsiProjectionAdapter';
+export { DefaultWSIDataProvider } from './DefaultWSIDataProvider';
+export { createDefaultWSIRenderPaths, createWSIRenderPathResolver, } from './WSIRenderPathResolver';
+export declare const wsiProjection: {
+    adapter: import("..").ViewportProjectionAdapter<import("./WSIViewportTypes").WSIViewState, import("../../../types").ViewPresentation, import("./WSIProjectionTypes").WSIProjectionSnapshot>;
+    getSnapshot: typeof getWSIProjectionSnapshot;
+};
+export type { WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, } from './wsiProjectionAdapter';
+export { default } from './WSIViewport';
+export type { WSICamera, WSIDataPresentation, WSIDataSetOptions, WSIPresentationProps, WSIProperties, WSIViewState, WSIViewportInput, WSIGenericViewportInput, } from './WSIViewportTypes';

package/dist/esm/RenderingEngine/GenericViewport/WSI/index.js

@@ -0,0 +1,8 @@
+import { getWSIProjectionSnapshot, wsiProjectionAdapter, } from './wsiProjectionAdapter';
+export { DefaultWSIDataProvider } from './DefaultWSIDataProvider';
+export { createDefaultWSIRenderPaths, createWSIRenderPathResolver, } from './WSIRenderPathResolver';
+export const wsiProjection = {
+    adapter: wsiProjectionAdapter,
+    getSnapshot: getWSIProjectionSnapshot,
+};
+export { default } from './WSIViewport';

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
+import { getWSIProjectionSnapshot } from './wsiProjectionSnapshot';
+import { type WSIProjectionSnapshot } from './WSIProjectionTypes';
+import type { WSIViewState } from './WSIViewportTypes';
+export { getWSIProjectionSnapshot };
+export type { WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, } from './WSIProjectionTypes';
+export declare const wsiProjectionAdapter: ViewportProjectionAdapter<WSIViewState, ViewPresentation, WSIProjectionSnapshot>;

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionAdapter.js

@@ -0,0 +1,12 @@
+import { ViewportType } from '../../../enums';
+import { getWSIProjectionPresentation, withWSIProjectionPresentation, } from './wsiProjectionPresentation';
+import { getWSIProjectionSnapshot } from './wsiProjectionSnapshot';
+import { WSI_PROJECTION_ID, } from './WSIProjectionTypes';
+export { getWSIProjectionSnapshot };
+export const wsiProjectionAdapter = {
+    id: WSI_PROJECTION_ID,
+    viewportTypes: [ViewportType.WHOLE_SLIDE_NEXT],
+    getSnapshot: (request) => getWSIProjectionSnapshot(request),
+    getPresentation: (snapshot, selector) => getWSIProjectionPresentation(snapshot, selector),
+    withPresentation: (snapshot, presentation, options) => withWSIProjectionPresentation(snapshot, presentation, options),
+};

package/dist/esm/RenderingEngine/GenericViewport/WSI/wsiProjectionPresentation.d.ts

@@ -0,0 +1,7 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewPresentationSelector } from '../../../types/IViewport';
+import type { ProjectionWriteOptions } from '../ViewportProjectionTypes';
+import type { WSIProjectionSnapshot } from './WSIProjectionTypes';
+import type { WSIViewState } from './WSIViewportTypes';
+export declare function getWSIProjectionPresentation(snapshot: WSIProjectionSnapshot, selector: ViewPresentationSelector | undefined): ViewPresentation;
+export declare function withWSIProjectionPresentation(snapshot: WSIProjectionSnapshot, presentation: Partial<ViewPresentation>, options?: ProjectionWriteOptions): WSIViewState;