@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Volume3D/vtkVolume3DInitialCamera.js

@@ -0,0 +1,110 @@
+import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import { MPR_CAMERA_VALUES } from '../../../constants';
+import { OrientationAxis } from '../../../enums';
+import { getConfiguration } from '../../../init';
+import { getCubeSizeInView } from '../../../utilities/getPlaneCubeIntersectionDimensions';
+import { getVolumeCenterIJK } from '../../Viewport';
+const VOLUME_3D_RADIUS_MULTIPLIER = 10;
+export function getInitialVolume3DCamera(ctx, imageVolume) {
+    const imageData = imageVolume.imageData;
+    if (!imageData) {
+        return;
+    }
+    const vtkCamera = ctx.vtk.renderer.getActiveCamera();
+    const orientation = getOrientationVectors({
+        fallbackViewPlaneNormal: vtkCamera.getViewPlaneNormal(),
+        fallbackViewUp: vtkCamera.getViewUp(),
+        imageVolume,
+        orientation: ctx.viewport.options.orientation,
+    });
+    const { viewPlaneNormal, viewUp } = orientation;
+    const bounds = imageData.getBounds();
+    const focalPoint = [0, 0, 0];
+    const dimensions = imageData.getDimensions();
+    const middleIJK = getVolumeCenterIJK(dimensions, imageData.getDirection(), viewPlaneNormal);
+    imageData.indexToWorld(middleIJK, focalPoint);
+    const { widthWorld, heightWorld } = getCubeSizeInView(imageData, viewPlaneNormal, viewUp);
+    const canvasWidth = ctx.vtk.canvas.width || ctx.viewport.element.clientWidth || 1;
+    const canvasHeight = ctx.vtk.canvas.height || ctx.viewport.element.clientHeight || 1;
+    const boundsAspectRatio = widthWorld / heightWorld;
+    const canvasAspectRatio = canvasWidth / canvasHeight;
+    const scaleFactor = boundsAspectRatio / canvasAspectRatio;
+    const insetImageMultiplier = getConfiguration().rendering?.useLegacyCameraFOV
+        ? 1.1
+        : 1;
+    const parallelScale = scaleFactor < 1
+        ? (insetImageMultiplier * heightWorld) / 2
+        : (insetImageMultiplier * heightWorld * scaleFactor) / 2;
+    const radius = getBoundsRadius(bounds) * VOLUME_3D_RADIUS_MULTIPLIER;
+    const distance = insetImageMultiplier * radius;
+    const viewUpToUse = Math.abs(vtkMath.dot(viewUp, viewPlaneNormal)) > 0.999
+        ? [-viewUp[2], viewUp[0], viewUp[1]]
+        : viewUp;
+    const position = [
+        focalPoint[0] + distance * viewPlaneNormal[0],
+        focalPoint[1] + distance * viewPlaneNormal[1],
+        focalPoint[2] + distance * viewPlaneNormal[2],
+    ];
+    if ('setPhysicalScale' in vtkCamera) {
+        vtkCamera.setPhysicalScale(radius);
+        vtkCamera.setPhysicalTranslation(-focalPoint[0], -focalPoint[1], -focalPoint[2]);
+    }
+    return {
+        focalPoint,
+        parallelProjection: ctx.viewport.options.parallelProjection ?? true,
+        parallelScale,
+        position,
+        viewAngle: 90,
+        viewPlaneNormal,
+        viewUp: viewUpToUse,
+    };
+}
+function getOrientationVectors(args) {
+    const { fallbackViewPlaneNormal, fallbackViewUp, imageVolume, orientation } = args;
+    if (!orientation) {
+        return {
+            viewPlaneNormal: fallbackViewPlaneNormal,
+            viewUp: fallbackViewUp,
+        };
+    }
+    if (typeof orientation === 'object' && orientation.viewPlaneNormal) {
+        return {
+            viewPlaneNormal: [...orientation.viewPlaneNormal],
+            viewUp: orientation.viewUp
+                ? [...orientation.viewUp]
+                : fallbackViewUp,
+        };
+    }
+    if (orientation === OrientationAxis.ACQUISITION) {
+        const { direction } = imageVolume;
+        return {
+            viewPlaneNormal: direction.slice(6, 9).map((x) => -x),
+            viewUp: direction.slice(3, 6).map((x) => -x),
+        };
+    }
+    const cameraValues = orientation === OrientationAxis.AXIAL_REFORMAT
+        ? MPR_CAMERA_VALUES.axial
+        : orientation === OrientationAxis.SAGITTAL_REFORMAT
+            ? MPR_CAMERA_VALUES.sagittal
+            : orientation === OrientationAxis.CORONAL_REFORMAT
+                ? MPR_CAMERA_VALUES.coronal
+                : typeof orientation === 'string'
+                    ? MPR_CAMERA_VALUES[orientation]
+                    : undefined;
+    if (!cameraValues) {
+        return {
+            viewPlaneNormal: fallbackViewPlaneNormal,
+            viewUp: fallbackViewUp,
+        };
+    }
+    return {
+        viewPlaneNormal: [...cameraValues.viewPlaneNormal],
+        viewUp: [...cameraValues.viewUp],
+    };
+}
+function getBoundsRadius(bounds) {
+    const width = (bounds[1] - bounds[0]) ** 2;
+    const height = (bounds[3] - bounds[2]) ** 2;
+    const depth = (bounds[5] - bounds[4]) ** 2;
+    return Math.sqrt(width + height + depth || 1) * 0.5;
+}

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

@@ -0,0 +1,6 @@
+import type { LoadedData } from '../ViewportArchitectureTypes';
+import type { WSIDataProvider, WSIPayload } from './WSIViewportTypes';
+export declare class DefaultWSIDataProvider implements WSIDataProvider {
+    load(dataId: string): Promise<LoadedData<WSIPayload>>;
+    private getDataSet;
+}

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

@@ -0,0 +1,35 @@
+import { addWSIMiniNavigationOverlayCss, loadWSIData, } from '../../../utilities/WSIUtilities';
+import { getGenericViewportWSIDataSet } from '../genericViewportDataSetAccess';
+export class DefaultWSIDataProvider {
+    async load(dataId) {
+        const dataSet = this.getDataSet(dataId);
+        if (!dataSet) {
+            throw new Error(`[WSIViewport] No registered WSI dataset metadata for ${dataId}`);
+        }
+        if (dataSet.options.miniNavigationOverlay !== false) {
+            addWSIMiniNavigationOverlayCss();
+        }
+        const loadedData = await loadWSIData({
+            imageIds: dataSet.imageIds,
+            client: dataSet.options.webClient,
+        });
+        return {
+            id: dataId,
+            type: 'wsi',
+            imageIds: dataSet.imageIds,
+            client: dataSet.options.webClient,
+            volumeImages: loadedData.volumeImages,
+            metadataDicomweb: loadedData.metadataDicomweb,
+            metadata: loadedData.metadata,
+            frameOfReferenceUID: loadedData.frameOfReferenceUID,
+            imageURISet: loadedData.imageURISet,
+        };
+    }
+    getDataSet(dataId) {
+        const registered = getGenericViewportWSIDataSet(dataId);
+        if (!registered) {
+            return;
+        }
+        return registered;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ViewportType } from '../../../enums';
+import type { DataAddOptions, LoadedData, RenderPathAttachment, RenderPathDefinition, RenderPath } from '../ViewportArchitectureTypes';
+import type { WSIDataPresentation, WSIViewportRenderContext } from './WSIViewportTypes';
+export declare class DicomMicroscopyRenderPath implements RenderPath<WSIViewportRenderContext> {
+    addData(ctx: WSIViewportRenderContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment<WSIDataPresentation>>;
+    private updateDataPresentation;
+    private applyViewState;
+    private getFrameOfReferenceUID;
+    private removeData;
+}
+export declare class DicomMicroscopyPath implements RenderPathDefinition<WSIViewportRenderContext> {
+    readonly id = "wsi:dicom-microscopy-viewer";
+    readonly type = ViewportType.WHOLE_SLIDE_NEXT;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): DicomMicroscopyRenderPath;
+}

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

@@ -0,0 +1,125 @@
+import { Events as EVENTS, ViewportType } from '../../../enums';
+import triggerEvent from '../../../utilities/triggerEvent';
+import { getDicomMicroscopyViewer } from '../../../utilities/WSIUtilities';
+const EVENT_POSTRENDER = 'postrender';
+export class DicomMicroscopyRenderPath {
+    async addData(ctx, data, options) {
+        const payload = data;
+        const DicomMicroscopyViewer = await getDicomMicroscopyViewer();
+        const microscopyElement = document.createElement('div');
+        microscopyElement.setAttribute('class', 'DicomMicroscopyViewer');
+        microscopyElement.style.background = 'black';
+        microscopyElement.style.width = '100%';
+        microscopyElement.style.height = '100%';
+        microscopyElement.style.position = 'absolute';
+        microscopyElement.style.left = '0';
+        microscopyElement.style.top = '0';
+        ctx.element.appendChild(microscopyElement);
+        const viewer = new DicomMicroscopyViewer.viewer.VolumeImageViewer({
+            client: payload.client,
+            metadata: payload.volumeImages,
+            controls: ['overview', 'position'],
+            retrieveRendered: false,
+            bindings: {},
+        });
+        viewer.render({ container: microscopyElement });
+        viewer.deactivateDragPanInteraction();
+        const map = viewer.getMap();
+        const postrenderHandler = () => {
+            triggerEvent(ctx.element, EVENTS.IMAGE_RENDERED, {
+                element: ctx.element,
+                viewportId: ctx.viewportId,
+                renderingEngineId: ctx.renderingEngineId,
+                rendering: {
+                    dataId: data.id,
+                    renderMode: 'wsi2d',
+                },
+            });
+        };
+        map.on(EVENT_POSTRENDER, postrenderHandler);
+        Object.assign(microscopyElement.style, {
+            '--ol-partial-background-color': 'rgba(127, 127, 127, 0.7)',
+            '--ol-foreground-color': '#000000',
+            '--ol-subtle-foreground-color': '#000',
+            '--ol-subtle-background-color': 'rgba(78, 78, 78, 0.5)',
+            background: 'none',
+        });
+        const rendering = {
+            renderMode: 'wsi2d',
+            microscopyElement,
+            viewer,
+            map,
+            transformUtils: DicomMicroscopyViewer.utils,
+            postrenderHandler,
+        };
+        return {
+            rendering,
+            updateDataPresentation: (props) => {
+                this.updateDataPresentation(rendering, props);
+            },
+            applyViewState: (camera) => {
+                this.applyViewState(rendering, camera);
+            },
+            getFrameOfReferenceUID: () => {
+                return this.getFrameOfReferenceUID(payload);
+            },
+            render: () => {
+                map.render?.();
+            },
+            resize: () => {
+                map.updateSize?.();
+                map.render?.();
+            },
+            removeData: () => {
+                this.removeData(rendering);
+            },
+        };
+    }
+    updateDataPresentation(rendering, props) {
+        const wsiProps = props;
+        const { microscopyElement } = rendering;
+        microscopyElement.style.display = wsiProps?.visible === false ? 'none' : '';
+        microscopyElement.style.opacity = String(wsiProps?.opacity ?? 1);
+    }
+    applyViewState(rendering, camera) {
+        const wsiCamera = camera;
+        const { map } = rendering;
+        const view = map?.getView?.();
+        if (!view) {
+            return;
+        }
+        if (typeof wsiCamera.resolution === 'number') {
+            view.setResolution?.(wsiCamera.resolution);
+        }
+        if (typeof wsiCamera.zoom === 'number') {
+            view.setZoom(wsiCamera.zoom);
+        }
+        if (wsiCamera.centerIndex) {
+            view.setCenter(wsiCamera.centerIndex);
+        }
+        if (typeof wsiCamera.rotation === 'number') {
+            view.setRotation(wsiCamera.rotation);
+        }
+    }
+    getFrameOfReferenceUID(payload) {
+        return payload.frameOfReferenceUID ?? undefined;
+    }
+    removeData(rendering) {
+        const { map, microscopyElement, viewer, postrenderHandler } = rendering;
+        map?.un?.(EVENT_POSTRENDER, postrenderHandler);
+        viewer?.cleanup?.();
+        microscopyElement.remove();
+    }
+}
+export class DicomMicroscopyPath {
+    constructor() {
+        this.id = 'wsi:dicom-microscopy-viewer';
+        this.type = ViewportType.WHOLE_SLIDE_NEXT;
+    }
+    matches(data, options) {
+        return data.type === 'wsi' && options.renderMode === 'wsi2d';
+    }
+    createRenderPath() {
+        return new DicomMicroscopyRenderPath();
+    }
+}

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

@@ -0,0 +1,40 @@
+import { ViewportType } from '../../../enums';
+import type { ICamera, Point2, Point3 } from '../../../types';
+import type { WSIMapViewLike } from '../../../utilities/WSIUtilities';
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot } from '../ViewportProjectionTypes';
+import type { WSIViewState } from './WSIViewportTypes';
+export declare const WSI_PROJECTION_ID = "wsi";
+export type WSIResolvedViewLike = {
+    state?: {
+        canvasHeight?: number;
+        canvasWidth?: number;
+        view?: WSIMapViewLike;
+        viewState: WSIViewState;
+    };
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    toICamera(): ICamera;
+    withZoom(zoom: number, canvasPoint?: Point2): WSIResolvedViewLike;
+};
+export type WSIProjectionViewport = {
+    type: ViewportType | string;
+    element?: HTMLDivElement;
+    getFrameOfReferenceUID?(): string | undefined;
+    getResolvedView?(): WSIResolvedViewLike | undefined;
+    getViewState?(): WSIViewState;
+};
+export interface WSIProjectionPresentation extends ProjectionPresentation<never> {
+}
+export interface WSIProjectionSnapshot extends ProjectionSnapshot<WSIViewState, WSIProjectionPresentation> {
+    canvasHeight: number;
+    canvasWidth: number;
+    resolvedView?: WSIResolvedViewLike;
+}
+export interface WSIProjectionRequest extends ProjectionRequest<WSIProjectionViewport> {
+    canvasHeight?: number;
+    canvasWidth?: number;
+    frameOfReferenceUID?: string;
+    resolvedView?: WSIResolvedViewLike;
+    viewState?: WSIViewState;
+}

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

@@ -0,0 +1,2 @@
+import { ViewportType } from '../../../enums';
+export const WSI_PROJECTION_ID = 'wsi';

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

@@ -0,0 +1,4 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import type { RenderPathDefinition } from '../ViewportArchitectureTypes';
+export declare function createDefaultWSIRenderPaths(): RenderPathDefinition[];
+export declare function createWSIRenderPathResolver(paths?: ReadonlyArray<RenderPathDefinition>): DefaultRenderPathResolver;

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

@@ -0,0 +1,8 @@
+import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver';
+import { DicomMicroscopyPath } from './DicomMicroscopyRenderPath';
+export function createDefaultWSIRenderPaths() {
+    return [new DicomMicroscopyPath()];
+}
+export function createWSIRenderPathResolver(paths = createDefaultWSIRenderPaths()) {
+    return new DefaultRenderPathResolver(paths);
+}

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

@@ -0,0 +1,26 @@
+import type { ICamera, Point2, Point3 } from '../../../types';
+import ResolvedViewportView from '../ResolvedViewportView';
+import type { WSIImageDataMetadata, WSIMapViewLike } from '../../../utilities/WSIUtilities';
+import type { WSIViewState } from './WSIViewportTypes';
+type WSIResolvedViewState = {
+    viewState: WSIViewState;
+    canvasHeight: number;
+    canvasWidth: number;
+    frameOfReferenceUID?: string | null;
+    metadata?: WSIImageDataMetadata;
+    view: WSIMapViewLike;
+};
+declare class WSIResolvedView extends ResolvedViewportView<WSIResolvedViewState> {
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+    getFrameOfReferenceUID(): string | undefined;
+    withZoom(zoom: number, canvasPoint?: Point2): WSIResolvedView;
+    protected buildICamera(): ICamera;
+    private canvasToIndex;
+    private getResolution;
+    private getResolutionForZoom;
+    private getCenterIndexForCanvasPoint;
+    private cloneWithViewState;
+}
+export type { WSIResolvedViewState };
+export default WSIResolvedView;

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

@@ -0,0 +1,104 @@
+import ResolvedViewportView from '../ResolvedViewportView';
+import { canvasToIndexForWSI, indexToCanvasForWSI, indexToWorldWSIMetadata, worldToIndexWSIMetadata, } from './wsiTransformUtils';
+class WSIResolvedView extends ResolvedViewportView {
+    canvasToWorld(canvasPos) {
+        const indexPoint = canvasToIndexForWSI({
+            canvasHeight: this.state.canvasHeight,
+            canvasPos,
+            canvasWidth: this.state.canvasWidth,
+            view: this.state.view,
+        });
+        return indexToWorldWSIMetadata(this.state.metadata, indexPoint);
+    }
+    worldToCanvas(worldPos) {
+        return indexToCanvasForWSI({
+            canvasHeight: this.state.canvasHeight,
+            canvasWidth: this.state.canvasWidth,
+            indexPos: worldToIndexWSIMetadata(this.state.metadata, worldPos),
+            view: this.state.view,
+        });
+    }
+    getFrameOfReferenceUID() {
+        return this.state.frameOfReferenceUID || undefined;
+    }
+    withZoom(zoom, canvasPoint) {
+        const nextZoom = Math.max(zoom, 0.001);
+        const nextResolution = this.getResolutionForZoom(nextZoom);
+        if (!canvasPoint) {
+            return this.cloneWithViewState({
+                ...this.state.viewState,
+                resolution: nextResolution,
+                zoom: nextZoom,
+            });
+        }
+        const indexPoint = this.canvasToIndex(canvasPoint);
+        return this.cloneWithViewState({
+            ...this.state.viewState,
+            centerIndex: this.getCenterIndexForCanvasPoint({
+                canvasPoint,
+                indexPoint,
+                resolution: nextResolution,
+            }),
+            resolution: nextResolution,
+            zoom: nextZoom,
+        });
+    }
+    buildICamera() {
+        const focalPoint = this.canvasToWorld([
+            this.state.canvasWidth / 2,
+            this.state.canvasHeight / 2,
+        ]);
+        const xSpacing = this.state.metadata?.spacing?.[0] || 1;
+        const resolution = this.getResolution();
+        return {
+            parallelProjection: true,
+            focalPoint,
+            position: focalPoint,
+            viewUp: [0, -1, 0],
+            parallelScale: this.state.canvasHeight * resolution * xSpacing,
+            viewPlaneNormal: [0, 0, 1],
+            rotation: this.state.view.getRotation?.() || this.state.viewState.rotation || 0,
+        };
+    }
+    canvasToIndex(canvasPos) {
+        const indexPoint = canvasToIndexForWSI({
+            canvasHeight: this.state.canvasHeight,
+            canvasPos,
+            canvasWidth: this.state.canvasWidth,
+            view: this.state.view,
+        });
+        return [indexPoint[0], indexPoint[1]];
+    }
+    getResolution() {
+        return (this.state.view.getResolution?.() || this.state.viewState.resolution || 1);
+    }
+    getResolutionForZoom(zoom) {
+        const viewZoom = this.state.view.getZoom?.() || this.state.viewState.zoom || 1;
+        return (this.state.view.getResolutionForZoom?.(zoom) ??
+            this.getResolution() / Math.pow(2, zoom - viewZoom));
+    }
+    getCenterIndexForCanvasPoint(args) {
+        const { canvasPoint, indexPoint, resolution } = args;
+        const pixelRatio = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;
+        const halfCanvasX = Math.max(this.state.canvasWidth, 1) / 2;
+        const halfCanvasY = Math.max(this.state.canvasHeight, 1) / 2;
+        const deltaCanvasX = canvasPoint[0] * pixelRatio - halfCanvasX;
+        const deltaCanvasY = canvasPoint[1] * pixelRatio - halfCanvasY;
+        const rotation = this.state.view.getRotation?.() || this.state.viewState.rotation || 0;
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const rotatedDeltaX = cos * deltaCanvasX + sin * deltaCanvasY;
+        const rotatedDeltaY = -sin * deltaCanvasX + cos * deltaCanvasY;
+        return [
+            indexPoint[0] - rotatedDeltaX * resolution,
+            indexPoint[1] + rotatedDeltaY * resolution,
+        ];
+    }
+    cloneWithViewState(viewState) {
+        return new WSIResolvedView({
+            ...this.state,
+            viewState,
+        });
+    }
+}
+export default WSIResolvedView;

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

@@ -0,0 +1,69 @@
+import { ViewportType } from '../../../enums';
+import type { CPUIImageData, Point2, Point3, ViewReference, ViewReferenceSpecifier } from '../../../types';
+import type { WSIMapViewLike } from '../../../utilities/WSIUtilities';
+import type { ViewportDataBinding } from '../ViewportArchitectureTypes';
+import GenericViewport from '../GenericViewport';
+import type { GenericViewportReferenceContext } from '../genericViewportReferenceCompatibility';
+import type { WSIDataPresentation, WSIPayload, WSIViewState, WSIViewportRenderContext, WSIViewportInput } from './WSIViewportTypes';
+import WSIResolvedView from './WSIResolvedView';
+export default class WSIViewport extends GenericViewport<WSIViewState, WSIDataPresentation, WSIViewportRenderContext> {
+    readonly type = ViewportType.WHOLE_SLIDE_NEXT;
+    readonly renderingEngineId: string;
+    modality: string;
+    protected renderContext: WSIViewportRenderContext;
+    private activeDataId?;
+    static get useCustomRenderingPipeline(): boolean;
+    getUseCustomRenderingPipeline(): boolean;
+    constructor(args: WSIViewportInput);
+    protected normalizeViewState(camera: WSIViewState): WSIViewState;
+    setDisplaySets(...entries: Array<{
+        displaySetId: string;
+    }>): Promise<void>;
+    setDisplaySetPresentation(props: Partial<WSIDataPresentation>): void;
+    setDisplaySetPresentation(displaySetId: string, props: Partial<WSIDataPresentation>): void;
+    computeTransforms(): {
+        indexToWorld: import("gl-matrix").mat4;
+        worldToIndexMatrix: import("gl-matrix").mat4;
+    };
+    getImageData(): CPUIImageData | null;
+    hasImageURI(imageURI: string): boolean;
+    setViewState(cameraPatch: Partial<WSIViewState>): void;
+    getResolvedView(): WSIResolvedView | undefined;
+    getCurrentImageId(): string | undefined;
+    getViewReference(_specifier?: ViewReferenceSpecifier): ViewReference;
+    setViewReference(_viewRef: ViewReference): void;
+    getFrameNumber(): number;
+    setFrameNumber(_frameNumber: number): Promise<void>;
+    resetViewState(): boolean;
+    getNumberOfSlices(): number;
+    resize(): void;
+    worldToIndexWSI(point: Point3): Point2;
+    indexToWorldWSI(point: Point2): Point3;
+    worldToIndex(point: Point3): Point3;
+    indexToWorld(point: Point3): Point3;
+    scroll(delta: number): void;
+    getRotation(): number;
+    getSliceIndex(): number;
+    getView(): WSIMapViewLike | undefined;
+    getZoom(): number;
+    setZoom(zoom: number, canvasPoint?: Point2): void;
+    getImageIds(): string[];
+    getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
+    getCurrentImageIdIndex(): number;
+    private applyResolvedViewState;
+    render(): void;
+    destroy(): void;
+    protected onDestroy(): void;
+    customRenderViewportToCanvas(): void;
+    setRendered(): void;
+    removeData(dataId: string): void;
+    protected getCurrentBinding(): ViewportDataBinding<WSIDataPresentation> | undefined;
+    protected getActiveDataId(): string | undefined;
+    protected getReferenceViewContexts(): GenericViewportReferenceContext[];
+    private applyVOIToRendering;
+    private syncCameraFromView;
+    private getMap;
+    protected getWSIData(): WSIPayload | undefined;
+    private getWSIRendering;
+    private clearGlobalDebugRefs;
+}