@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/dist/esm/RenderingEngine/VideoViewport.d.ts

@@ -0,0 +1,122 @@
+import type { mat4 } from 'gl-matrix';
+import { VideoEnums as VideoViewportEnum } from '../enums';
+import type { VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types';
+import { Transform } from './helpers/cpuFallback/rendering/transform';
+import Viewport from './Viewport';
+import CanvasActor from './CanvasActor';
+export type CanvasScalarData = Uint8ClampedArray & {
+    frameNumber?: number;
+    getRange?: () => [number, number];
+};
+declare class VideoViewport extends Viewport {
+    static frameRangeExtractor: RegExp;
+    modality: any;
+    protected imageId: string;
+    readonly uid: any;
+    readonly renderingEngineId: string;
+    readonly canvasContext: CanvasRenderingContext2D;
+    private videoElement?;
+    private videoWidth;
+    private videoHeight;
+    private loop;
+    private mute;
+    private isPlaying;
+    private scrollSpeed;
+    private playbackRate;
+    private scalarData;
+    private initialRender;
+    private frameRange;
+    protected metadata: any;
+    private fps;
+    private numberOfFrames;
+    private videoCamera;
+    private feFilter;
+    private averageWhite;
+    private voiRange;
+    constructor(props: VideoViewportInput);
+    static get useCustomRenderingPipeline(): boolean;
+    private addEventListeners;
+    private removeEventListeners;
+    private elementDisabledHandler;
+    getImageDataMetadata(image: IImage | string): {
+        bitsAllocated: number;
+        numberOfComponents: number;
+        origin: any;
+        rows: any;
+        columns: any;
+        direction: number[];
+        dimensions: any[];
+        spacing: any[];
+        hasPixelSpacing: boolean;
+        numVoxels: number;
+        imagePlaneModule: any;
+    };
+    setDataIds(imageIds: string[], options?: ImageSetOptions): void;
+    setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
+    setVideoURL(videoURL: string): Promise<unknown>;
+    getImageIds(): string[];
+    togglePlayPause(): boolean;
+    play(): Promise<void>;
+    pause(): void;
+    scroll(delta?: number): Promise<void>;
+    start(): Promise<void>;
+    end(): Promise<void>;
+    setTime(timeInSeconds: number): Promise<void>;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    setFrameNumber(frame: number): Promise<void>;
+    setFrameRange(frameRange: number[]): void;
+    getFrameRange(): [number, number];
+    setProperties(props: VideoViewportProperties): void;
+    setPlaybackRate(rate?: number): void;
+    setScrollSpeed(scrollSpeed?: number, unit?: VideoViewportEnum.SpeedUnit): void;
+    getProperties: () => VideoViewportProperties;
+    resetProperties(): void;
+    protected getScalarData(): CanvasScalarData;
+    getImageData(): IImageData | CPUIImageData;
+    getMiddleSliceData: () => never;
+    useCustomRenderingPipeline: boolean;
+    hasImageURI(imageURI: string): boolean;
+    setVOI(voiRange: VOIRange): void;
+    setWindowLevel(windowWidth?: number, windowCenter?: number): void;
+    setAverageWhite(averageWhite: [number, number, number]): void;
+    protected setColorTransform(): void;
+    setCamera(camera: ICamera): void;
+    getCurrentImageId(): string;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    setViewReference(viewRef: ViewReference): void;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    getFrameNumber(): number;
+    getCurrentImageIdIndex(): number;
+    getSliceIndex(): number;
+    getCamera(): ICamera;
+    resetCamera: () => boolean;
+    getNumberOfSlices: () => number;
+    getFrameRate(): number;
+    getFrameOfReferenceUID: () => string;
+    resize: () => void;
+    canvasToWorld: (canvasPos: Point2, destPos?: Point3) => Point3;
+    worldToCanvas: (worldPos: Point3) => Point2;
+    getPan(): Point2;
+    getRotation: () => number;
+    protected canvasToIndex: (canvasPos: Point2) => Point2;
+    protected indexToCanvas: (indexPos: Point2) => Point2;
+    private refreshRenderValues;
+    private getWorldToCanvasRatio;
+    private getCanvasToWorldRatio;
+    customRenderViewportToCanvas: () => void;
+    protected getTransform(): Transform;
+    updateCameraClippingPlanesAndRange(): void;
+    addImages(stackInputs: IStackInput[]): void;
+    protected createActorMapper(image: any): CanvasActor;
+    private renderFrame;
+    private renderWhilstPlaying;
+}
+export default VideoViewport;

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -2,11 +2,13 @@ import { vec3 } from 'gl-matrix';
 import { Events as EVENTS, VideoEnums as VideoViewportEnum, MetadataModules, } from '../enums';
 import * as metaData from '../metaData';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 import Viewport from './Viewport';
 import { getOrCreateCanvas } from './helpers';
 import CanvasActor from './CanvasActor';
-import cache from '../cache';
+import cache from '../cache/cache';
+import uuidv4 from '../utilities/uuidv4';
+import { pointInShapeCallback } from '../utilities/pointInShapeCallback';
 class VideoViewport extends Viewport {
     static { this.frameRangeExtractor = /(\/frames\/|[&?]frameNumber=)([^/&?]*)/i; }
     constructor(props) {
@@ -23,7 +25,6 @@ class VideoViewport extends Viewport {
         this.playbackRate = 1;
         this.frameRange = [0, 0];
         this.fps = 30;
-        this.numberOfFrames = 0;
         this.videoCamera = {
             panWorld: [0, 0],
             parallelScale: 1,
@@ -41,16 +42,21 @@ class VideoViewport extends Viewport {
                 voiRange: { ...this.voiRange },
             };
         };
+        this.getMiddleSliceData = () => {
+            throw new Error('Method not implemented.');
+        };
+        this.useCustomRenderingPipeline = true;
         this.resetCamera = () => {
             this.refreshRenderValues();
             this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
-            if (this.isPlaying === false) {
+            if (!this.isPlaying) {
                 this.renderFrame();
             }
             return true;
         };
         this.getNumberOfSlices = () => {
-            return Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            const computedSlices = Math.round((this.videoElement.duration * this.fps) / this.scrollSpeed);
+            return isNaN(computedSlices) ? this.numberOfFrames : computedSlices;
         };
         this.getFrameOfReferenceUID = () => {
             return this.videoElement.src;
@@ -63,7 +69,7 @@ class VideoViewport extends Viewport {
                 canvas.height = clientHeight;
             }
             this.refreshRenderValues();
-            if (this.isPlaying === false) {
+            if (!this.isPlaying) {
                 this.renderFrame();
             }
         };
@@ -98,17 +104,21 @@ class VideoViewport extends Viewport {
         };
         this.indexToCanvas = (indexPos) => {
             const transform = this.getTransform();
-            return (transform.transformPoint(indexPos).map((it) => it / devicePixelRatio));
+            return transform
+                .transformPoint(indexPos)
+                .map((it) => it / devicePixelRatio);
         };
         this.customRenderViewportToCanvas = () => {
             this.renderFrame();
         };
         this.renderFrame = () => {
+            const dpr = window.devicePixelRatio || 1;
             const transform = this.getTransform();
             const transformationMatrix = transform.getMatrix();
             const ctx = this.canvasContext;
             ctx.resetTransform();
-            ctx.transform(transformationMatrix[0], transformationMatrix[1], transformationMatrix[2], transformationMatrix[3], transformationMatrix[4], transformationMatrix[5]);
+            ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            ctx.transform(transformationMatrix[0] / dpr, transformationMatrix[1] / dpr, transformationMatrix[2] / dpr, transformationMatrix[3] / dpr, transformationMatrix[4] / dpr, transformationMatrix[5] / dpr);
             ctx.drawImage(this.videoElement, 0, 0, this.videoWidth, this.videoHeight);
             for (const actor of this.getActors()) {
                 actor.actor.render(this, this.canvasContext);
@@ -126,6 +136,8 @@ class VideoViewport extends Viewport {
                 element: this.element,
                 viewportId: this.id,
                 viewport: this,
+                imageIndex: this.getCurrentImageIdIndex(),
+                numberOfSlices: this.numberOfFrames,
                 renderingEngineId: this.renderingEngineId,
                 time: this.videoElement.currentTime,
                 duration: this.videoElement.duration,
@@ -204,7 +216,7 @@ class VideoViewport extends Viewport {
         this.hasPixelSpacing = !!imagePlaneModule.columnPixelSpacing;
         return {
             bitsAllocated: 8,
-            numComps: 3,
+            numberOfComponents: 3,
             origin,
             rows,
             columns,
@@ -216,15 +228,23 @@ class VideoViewport extends Viewport {
             imagePlaneModule,
         };
     }
+    setDataIds(imageIds, options) {
+        this.setVideo(imageIds[0], (options.viewReference?.sliceIndex || 0) + 1);
+    }
     setVideo(imageId, frameNumber) {
         this.imageId = Array.isArray(imageId) ? imageId[0] : imageId;
-        const { rendered } = metaData.get(MetadataModules.IMAGE_URL, imageId);
+        const imageUrlModule = metaData.get(MetadataModules.IMAGE_URL, imageId);
+        if (!imageUrlModule?.rendered) {
+            throw new Error(`Video Image ID ${imageId} does not have a rendered video view`);
+        }
+        const { rendered } = imageUrlModule;
         const generalSeries = metaData.get(MetadataModules.GENERAL_SERIES, imageId);
         this.modality = generalSeries?.Modality;
         this.metadata = this.getImageDataMetadata(imageId);
+        let { cineRate, numberOfFrames } = metaData.get(MetadataModules.CINE, imageId);
+        this.numberOfFrames = numberOfFrames;
         return this.setVideoURL(rendered).then(() => {
-            let { cineRate, numberOfFrames } = metaData.get(MetadataModules.CINE, imageId);
-            if (!numberOfFrames) {
+            if (!numberOfFrames || numberOfFrames === 1) {
                 numberOfFrames = Math.round(this.videoElement.duration * (cineRate || 30));
             }
             if (!cineRate) {
@@ -281,18 +301,18 @@ class VideoViewport extends Viewport {
     async play() {
         try {
             if (!this.isPlaying) {
-                await this.videoElement.play();
                 this.isPlaying = true;
+                await this.videoElement.play();
                 this.renderWhilstPlaying();
             }
         }
         catch (e) {
         }
     }
-    async pause() {
+    pause() {
         try {
-            await this.videoElement.pause();
             this.isPlaying = false;
+            this.videoElement.pause();
         }
         catch (e) {
         }
@@ -346,6 +366,9 @@ class VideoViewport extends Viewport {
             videoElement.addEventListener('seeked', seekEventListener);
         }
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     async setFrameNumber(frame) {
         this.setTime((frame - 1) / this.fps);
     }
@@ -407,12 +430,21 @@ class VideoViewport extends Viewport {
         if (this.scalarData?.frameNumber === this.getFrameNumber()) {
             return this.scalarData;
         }
+        if (!this.videoElement ||
+            !this.videoElement.videoWidth ||
+            !this.videoElement.videoHeight) {
+            console.debug('Video not ready yet, returning empty scalar data');
+            const emptyData = new Uint8ClampedArray();
+            emptyData.getRange = () => [0, 255];
+            emptyData.frameNumber = -1;
+            return emptyData;
+        }
         const canvas = document.createElement('canvas');
-        canvas.width = this.videoWidth;
-        canvas.height = this.videoHeight;
+        canvas.width = this.videoElement.videoWidth;
+        canvas.height = this.videoElement.videoHeight;
         const context = canvas.getContext('2d');
         context.drawImage(this.videoElement, 0, 0);
-        const canvasData = context.getImageData(0, 0, this.videoWidth, this.videoHeight);
+        const canvasData = context.getImageData(0, 0, canvas.width, canvas.height);
         const scalarData = canvasData.data;
         scalarData.getRange = () => [0, 255];
         scalarData.frameNumber = this.getFrameNumber();
@@ -423,26 +455,41 @@ class VideoViewport extends Viewport {
         const { metadata } = this;
         const spacing = metadata.spacing;
         const imageData = {
+            getDirection: () => metadata.direction,
+            getDimensions: () => metadata.dimensions,
+            getRange: () => [0, 255],
+            getScalarData: () => this.getScalarData(),
+            getSpacing: () => metadata.spacing,
+            worldToIndex: (point) => {
+                const canvasPoint = this.worldToCanvas(point);
+                const pixelCoord = this.canvasToIndex(canvasPoint);
+                return [pixelCoord[0], pixelCoord[1], 0];
+            },
+            indexToWorld: (point, destPoint) => {
+                const canvasPoint = this.indexToCanvas([point[0], point[1]]);
+                return this.canvasToWorld(canvasPoint, destPoint);
+            },
+        };
+        const imageDataForReturn = {
             dimensions: metadata.dimensions,
             spacing,
             origin: metadata.origin,
             direction: metadata.direction,
-            metadata: { Modality: this.modality },
+            metadata: {
+                Modality: this.modality,
+                FrameOfReferenceUID: metadata.FrameOfReferenceUID,
+            },
             getScalarData: () => this.getScalarData(),
-            imageData: {
-                getDirection: () => metadata.direction,
-                getDimensions: () => metadata.dimensions,
-                getRange: () => [0, 255],
-                getScalarData: () => this.getScalarData(),
-                getSpacing: () => metadata.spacing,
-                worldToIndex: (point) => {
-                    const canvasPoint = this.worldToCanvas(point);
-                    const pixelCoord = this.canvasToIndex(canvasPoint);
-                    return [pixelCoord[0], pixelCoord[1], 0];
-                },
-                indexToWorld: (point, destPoint) => {
-                    const canvasPoint = this.indexToCanvas([point[0], point[1]]);
-                    return this.canvasToWorld(canvasPoint, destPoint);
+            scalarData: this.getScalarData(),
+            imageData,
+            voxelManager: {
+                forEach: (callback, options) => {
+                    return pointInShapeCallback(options.imageData, {
+                        pointInShapeFn: options.isInObject ?? (() => true),
+                        callback: callback,
+                        boundsIJK: options.boundsIJK,
+                        returnPoints: options.returnPoints ?? false,
+                    });
                 },
             },
             hasPixelSpacing: this.hasPixelSpacing,
@@ -455,14 +502,14 @@ class VideoViewport extends Viewport {
             get: () => this.getScalarData(),
             enumerable: true,
         });
-        return imageData;
+        return imageDataForReturn;
     }
     hasImageURI(imageURI) {
         const framesMatch = imageURI.match(VideoViewport.frameRangeExtractor);
         const testURI = framesMatch
             ? imageURI.substring(0, framesMatch.index)
             : imageURI;
-        return this.imageId.indexOf(testURI) !== -1;
+        return this.imageId.includes(testURI);
     }
     setVOI(voiRange) {
         this.voiRange = voiRange;
@@ -527,7 +574,7 @@ class VideoViewport extends Viewport {
         }
         this.canvasContext.fillStyle = 'rgba(0,0,0,1)';
         this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
-        if (this.isPlaying === false) {
+        if (!this.isPlaying) {
             this.renderFrame();
         }
     }
@@ -537,7 +584,7 @@ class VideoViewport extends Viewport {
             : `/frames/${this.getFrameNumber()}`);
         return current;
     }
-    getReferenceId(specifier = {}) {
+    getViewReferenceId(specifier = {}) {
         const { sliceIndex: sliceIndex } = specifier;
         if (sliceIndex === undefined) {
             return `videoId:${this.getCurrentImageId()}`;
@@ -573,15 +620,23 @@ class VideoViewport extends Viewport {
             return false;
         }
         const match = referencedImageId.match(VideoViewport.frameRangeExtractor);
-        if (!match || !match[2]) {
+        if (!match[2]) {
             return true;
         }
         const range = match[2].split('-').map((it) => Number(it));
         const frame = currentIndex + 1;
         return range[0] <= frame && frame <= (range[1] ?? range[0]);
     }
+    setViewReference(viewRef) {
+        if (typeof viewRef.sliceIndex === 'number') {
+            this.setFrameNumber(viewRef.sliceIndex + 1);
+        }
+        else if (Array.isArray(viewRef.sliceIndex)) {
+            this.setFrameRange(viewRef.sliceIndex);
+        }
+    }
     getViewReference(viewRefSpecifier) {
-        let sliceIndex = viewRefSpecifier?.sliceIndex;
+        let sliceIndex = viewRefSpecifier?.sliceIndex ?? this.getSliceIndex();
         if (!sliceIndex) {
             sliceIndex = this.isPlaying
                 ? [this.frameRange[0] - 1, this.frameRange[1] - 1]
@@ -589,7 +644,7 @@ class VideoViewport extends Viewport {
         }
         return {
             ...super.getViewReference(viewRefSpecifier),
-            referencedImageId: this.getReferenceId(viewRefSpecifier),
+            referencedImageId: this.getViewReferenceId(viewRefSpecifier),
             sliceIndex: sliceIndex,
         };
     }
@@ -600,7 +655,7 @@ class VideoViewport extends Viewport {
         return Math.round(this.videoElement.currentTime * this.fps);
     }
     getSliceIndex() {
-        return this.getCurrentImageIdIndex();
+        return this.getCurrentImageIdIndex() / this.scrollSpeed;
     }
     getCamera() {
         const { parallelScale } = this.videoCamera;
@@ -618,6 +673,9 @@ class VideoViewport extends Viewport {
             viewPlaneNormal: [0, 0, 1],
         };
     }
+    getFrameRate() {
+        return this.fps;
+    }
     getPan() {
         const panWorld = this.videoCamera.panWorld;
         return [panWorld[0], panWorld[1]];
@@ -670,10 +728,14 @@ class VideoViewport extends Viewport {
         stackInputs.forEach((stackInput) => {
             const image = cache.getImage(stackInput.imageId);
             const imageActor = this.createActorMapper(image);
+            const uid = stackInput.actorUID ?? uuidv4();
             if (imageActor) {
-                actors.push({ uid: stackInput.actorUID, actor: imageActor });
+                actors.push({ uid, actor: imageActor });
                 if (stackInput.callback) {
-                    stackInput.callback({ imageActor, imageId: stackInput.imageId });
+                    stackInput.callback({
+                        imageActor: imageActor,
+                        imageId: stackInput.imageId,
+                    });
                 }
             }
         });
@@ -684,4 +746,3 @@ class VideoViewport extends Viewport {
     }
 }
 export default VideoViewport;
-//# sourceMappingURL=VideoViewport.js.map

package/dist/esm/RenderingEngine/Viewport.d.ts

@@ -0,0 +1,136 @@
+import type { vtkCamera } from '@kitware/vtk.js/Rendering/Core/Camera';
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+import type { mat4 } from 'gl-matrix';
+import ViewportStatus from '../enums/ViewportStatus';
+import ViewportType from '../enums/ViewportType';
+import type { ICamera, ActorEntry, IRenderingEngine, ViewportInputOptions, Point2, Point3, FlipDirection, DisplayArea, ViewPresentation, ViewReference, ViewportProperties } from '../types';
+import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
+import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
+import type IImageCalibration from '../types/IImageCalibration';
+import { InterpolationType } from '../enums';
+import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
+declare class Viewport {
+    static readonly CameraViewPresentation: ViewPresentationSelector;
+    static readonly TransferViewPresentation: ViewPresentationSelector;
+    readonly id: string;
+    readonly element: HTMLDivElement;
+    readonly canvas: HTMLCanvasElement;
+    readonly renderingEngineId: string;
+    readonly type: ViewportType;
+    protected insetImageMultiplier: number;
+    protected flipHorizontal: boolean;
+    protected flipVertical: boolean;
+    isDisabled: boolean;
+    viewportStatus: ViewportStatus;
+    sx: number;
+    sy: number;
+    sWidth: number;
+    sHeight: number;
+    _actors: Map<string, ActorEntry>;
+    readonly defaultOptions: ViewportInputOptions;
+    options: ViewportInputOptions;
+    _suppressCameraModifiedEvents: boolean;
+    readonly suppressEvents: boolean;
+    protected hasPixelSpacing: boolean;
+    protected calibration: IImageCalibration;
+    protected initialCamera: ICamera;
+    protected fitToCanvasCamera: ICamera;
+    constructor(props: ViewportInput);
+    getRotation: () => number;
+    getFrameOfReferenceUID: () => string;
+    canvasToWorld: (canvasPos: Point2) => Point3;
+    worldToCanvas: (worldPos: Point3) => Point2;
+    customRenderViewportToCanvas: () => unknown;
+    resize: () => void;
+    getProperties: () => ViewportProperties;
+    updateRenderingPipeline: () => void;
+    getNumberOfSlices: () => number;
+    protected setRotation: (_rotation: number) => void;
+    static get useCustomRenderingPipeline(): boolean;
+    private viewportWidgets;
+    addWidget: (widgetId: any, widget: any) => void;
+    getWidget: (id: any) => any;
+    getWidgets: () => any[];
+    removeWidgets: () => void;
+    setRendered(): void;
+    getRenderingEngine(): IRenderingEngine;
+    getRenderer(): vtkRenderer;
+    render(): void;
+    setOptions(options: ViewportInputOptions, immediate?: boolean): void;
+    reset(immediate?: boolean): void;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    protected flip({ flipHorizontal, flipVertical }: FlipDirection): void;
+    private getDefaultImageData;
+    getDefaultActor(): ActorEntry;
+    getActors(): ActorEntry[];
+    getActorUIDs(): string[];
+    getActor(actorUID: string): ActorEntry;
+    getActorUIDByIndex(index: number): string;
+    getActorByIndex(index: number): ActorEntry;
+    setActors(actors: ActorEntry[]): void;
+    _removeActor(actorUID: string): void;
+    removeActors(actorUIDs: string[]): void;
+    addActors(actors: ActorEntry[], options?: {
+        resetCamera?: boolean;
+    }): void;
+    addActor(actorEntry: ActorEntry): void;
+    removeAllActors(): void;
+    protected resetCameraNoEvent(): void;
+    protected setCameraNoEvent(camera: ICamera): void;
+    private _getViewImageDataIntersections;
+    protected setInterpolationType(_interpolationType: InterpolationType, _arg?: any): void;
+    setDisplayArea(displayArea: DisplayArea, suppressEvents?: boolean): void;
+    protected setDisplayAreaScale(displayArea: DisplayArea): void;
+    protected setDisplayAreaFit(displayArea: DisplayArea): void;
+    getDisplayArea(): DisplayArea | undefined;
+    resetCamera(options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+        storeAsInitialCamera?: boolean;
+    }): boolean;
+    protected setInitialCamera(camera: ICamera): void;
+    protected setFitToCanvasCamera(camera: ICamera): void;
+    getPan(initialCamera?: ICamera): Point2;
+    getCurrentImageIdIndex(): number;
+    getSliceIndex(): number;
+    getImageData(): any;
+    getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
+    setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
+    getZoom(compareCamera?: ICamera): number;
+    setZoom(value: number, storeAsInitialCamera?: boolean): void;
+    private _getFocalPointForViewPlaneReset;
+    getCanvas(): HTMLCanvasElement;
+    protected getVtkActiveCamera(): vtkCamera | vtkSlabCamera;
+    protected getCameraNoRotation(): ICamera;
+    getCamera(): ICamera;
+    setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
+    triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void;
+    updateCameraClippingPlanesAndRange(): void;
+    protected updateClippingPlanesForActors(updatedCamera: ICamera): Promise<void>;
+    setOrientationOfClippingPlanes(vtkPlanes: vtkPlane[], slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void;
+    getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
+    private _getWorldDistanceViewUpAndViewRight;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
+    getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
+    setViewReference(viewRef: ViewReference): void;
+    setViewPresentation(viewPres: ViewPresentation): void;
+    _getCorners(bounds: number[]): number[][];
+    _getFocalPointForResetCamera(centeredFocalPoint: Point3, previousCamera: ICamera, { resetPan, resetToCenter }: {
+        resetPan?: boolean;
+        resetToCenter?: boolean;
+    }): Point3;
+    _isInBounds(point: Point3, bounds: number[]): boolean;
+    _getEdges(bounds: number[]): [number[], number[]][];
+    static boundsRadius(bounds: number[]): number;
+    setDataIds(_imageIds: string[], _options?: DataSetOptions): void;
+}
+export default Viewport;