@cornerstonejs/core 3.29.0 → 3.29.2

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

@@ -0,0 +1,53 @@
+import type IStackViewport from '../types/IStackViewport';
+import type IVolumeViewport from '../types/IVolumeViewport';
+import type * as EventTypes from '../types/EventTypes';
+import type { PublicViewportInput, InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
+export declare const VIEWPORT_MIN_SIZE = 2;
+declare abstract class BaseRenderingEngine {
+    readonly id: string;
+    hasBeenDestroyed: boolean;
+    offscreenMultiRenderWindow: any;
+    readonly offScreenCanvasContainer: HTMLDivElement;
+    protected _viewports: Map<string, IViewport>;
+    protected _needsRender: Set<string>;
+    protected _animationFrameSet: boolean;
+    protected _animationFrameHandle: number | null;
+    protected useCPURendering: boolean;
+    constructor(id?: string);
+    enableElement(viewportInputEntry: PublicViewportInput): void;
+    disableElement(viewportId: string): void;
+    setViewports(publicViewportInputEntries: PublicViewportInput[]): void;
+    resize(immediate?: boolean, keepCamera?: boolean): void;
+    getViewport(viewportId: string): IViewport;
+    getViewports(): IViewport[];
+    getStackViewport(viewportId: string): IStackViewport;
+    getStackViewports(): IStackViewport[];
+    getVolumeViewports(): IVolumeViewport[];
+    render(): void;
+    renderFrameOfReference: (FrameOfReferenceUID: string) => void;
+    renderViewports(viewportIds: string[]): void;
+    renderViewport(viewportId: string): void;
+    destroy(): void;
+    fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
+    private _normalizeViewportInputEntry;
+    private _normalizeViewportInputEntries;
+    private _resizeUsingCustomResizeHandler;
+    private _removeViewport;
+    private addCustomViewport;
+    private setCustomViewports;
+    protected _getViewportsAsArray(): IViewport[];
+    private _setViewportsToBeRenderedNextFrame;
+    private _render;
+    private _resetViewport;
+    private _clearAnimationFrame;
+    private _reset;
+    protected _throwIfDestroyed(): void;
+    protected abstract _resizeVTKViewports(vtkDrivenViewports: (IStackViewport | IVolumeViewport)[], keepCamera: boolean, immediate: boolean): void;
+    protected abstract enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
+    protected abstract addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput, offscreenCanvasProperties?: unknown): void;
+    protected abstract _renderFlaggedViewports(): void;
+    protected abstract setVtkjsDrivenViewports(viewportInputEntries: NormalizedViewportInput[]): void;
+    protected abstract renderViewportUsingCustomOrVtkPipeline(viewport: IViewport): EventTypes.ImageRenderedEventDetail;
+    protected abstract _renderViewportFromVtkCanvasToOnscreenCanvas(viewport: IViewport, offScreenCanvas: HTMLCanvasElement): EventTypes.ImageRenderedEventDetail;
+}
+export default BaseRenderingEngine;

package/dist/esm/RenderingEngine/BaseRenderingEngine.js

@@ -0,0 +1,341 @@
+import Events from '../enums/Events';
+import renderingEngineCache from './renderingEngineCache';
+import eventTarget from '../eventTarget';
+import uuidv4 from '../utilities/uuidv4';
+import triggerEvent from '../utilities/triggerEvent';
+import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
+import ViewportType from '../enums/ViewportType';
+import BaseVolumeViewport from './BaseVolumeViewport';
+import StackViewport from './StackViewport';
+import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
+import getOrCreateCanvas from './helpers/getOrCreateCanvas';
+import { getShouldUseCPURendering, isCornerstoneInitialized } from '../init';
+import viewportTypeToViewportClass from './helpers/viewportTypeToViewportClass';
+import { OrientationAxis } from '../enums';
+export const VIEWPORT_MIN_SIZE = 2;
+class BaseRenderingEngine {
+    constructor(id) {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this.renderFrameOfReference = (FrameOfReferenceUID) => {
+            const viewports = this._getViewportsAsArray();
+            const viewportIdsWithSameFrameOfReferenceUID = viewports.map((vp) => {
+                if (vp.getFrameOfReferenceUID() === FrameOfReferenceUID) {
+                    return vp.id;
+                }
+            });
+            this.renderViewports(viewportIdsWithSameFrameOfReferenceUID);
+        };
+        this.id = id ? id : uuidv4();
+        this.useCPURendering = getShouldUseCPURendering();
+        renderingEngineCache.set(this);
+        if (!isCornerstoneInitialized()) {
+            throw new Error('@cornerstonejs/core is not initialized, run init() first');
+        }
+        if (!this.useCPURendering) {
+            this.offscreenMultiRenderWindow =
+                vtkOffscreenMultiRenderWindow.newInstance();
+            this.offScreenCanvasContainer = document.createElement('div');
+            this.offscreenMultiRenderWindow.setContainer(this.offScreenCanvasContainer);
+        }
+        this._viewports = new Map();
+        this.hasBeenDestroyed = false;
+    }
+    enableElement(viewportInputEntry) {
+        const viewportInput = this._normalizeViewportInputEntry(viewportInputEntry);
+        this._throwIfDestroyed();
+        const { element, viewportId } = viewportInput;
+        if (!element) {
+            throw new Error('No element provided');
+        }
+        const viewport = this.getViewport(viewportId);
+        if (viewport) {
+            this.disableElement(viewportId);
+        }
+        const { type } = viewportInput;
+        const viewportUsesCustomRenderingPipeline = viewportTypeUsesCustomRenderingPipeline(type);
+        if (!this.useCPURendering && !viewportUsesCustomRenderingPipeline) {
+            this.enableVTKjsDrivenViewport(viewportInput);
+        }
+        else {
+            this.addCustomViewport(viewportInput);
+        }
+        const canvas = getOrCreateCanvas(element);
+        const { background } = viewportInput.defaultOptions;
+        this.fillCanvasWithBackgroundColor(canvas, background);
+    }
+    disableElement(viewportId) {
+        this._throwIfDestroyed();
+        const viewport = this.getViewport(viewportId);
+        if (!viewport) {
+            console.warn(`viewport ${viewportId} does not exist`);
+            return;
+        }
+        this._resetViewport(viewport);
+        if (!viewportTypeUsesCustomRenderingPipeline(viewport.type) &&
+            !this.useCPURendering) {
+            this.offscreenMultiRenderWindow.removeRenderer(viewportId);
+        }
+        this._removeViewport(viewportId);
+        viewport.isDisabled = true;
+        this._needsRender.delete(viewportId);
+        const viewports = this.getViewports();
+        if (!viewports.length) {
+            this._clearAnimationFrame();
+        }
+    }
+    setViewports(publicViewportInputEntries) {
+        const viewportInputEntries = this._normalizeViewportInputEntries(publicViewportInputEntries);
+        this._throwIfDestroyed();
+        this._reset();
+        const vtkDrivenViewportInputEntries = [];
+        const customRenderingViewportInputEntries = [];
+        viewportInputEntries.forEach((vpie) => {
+            if (!this.useCPURendering &&
+                !viewportTypeUsesCustomRenderingPipeline(vpie.type)) {
+                vtkDrivenViewportInputEntries.push(vpie);
+            }
+            else {
+                customRenderingViewportInputEntries.push(vpie);
+            }
+        });
+        this.setVtkjsDrivenViewports(vtkDrivenViewportInputEntries);
+        this.setCustomViewports(customRenderingViewportInputEntries);
+        viewportInputEntries.forEach((vp) => {
+            const canvas = getOrCreateCanvas(vp.element);
+            const { background } = vp.defaultOptions;
+            this.fillCanvasWithBackgroundColor(canvas, background);
+        });
+    }
+    resize(immediate = true, keepCamera = true) {
+        this._throwIfDestroyed();
+        const viewports = this._getViewportsAsArray();
+        const vtkDrivenViewports = [];
+        const customRenderingViewports = [];
+        viewports.forEach((vpie) => {
+            if (!viewportTypeUsesCustomRenderingPipeline(vpie.type)) {
+                vtkDrivenViewports.push(vpie);
+            }
+            else {
+                customRenderingViewports.push(vpie);
+            }
+        });
+        if (vtkDrivenViewports.length) {
+            this._resizeVTKViewports(vtkDrivenViewports, keepCamera, immediate);
+        }
+        if (customRenderingViewports.length) {
+            this._resizeUsingCustomResizeHandler(customRenderingViewports, keepCamera, immediate);
+        }
+    }
+    getViewport(viewportId) {
+        return this._viewports?.get(viewportId);
+    }
+    getViewports() {
+        this._throwIfDestroyed();
+        return this._getViewportsAsArray();
+    }
+    getStackViewport(viewportId) {
+        this._throwIfDestroyed();
+        const viewport = this.getViewport(viewportId);
+        if (!viewport) {
+            throw new Error(`Viewport with Id ${viewportId} does not exist`);
+        }
+        if (!(viewport instanceof StackViewport)) {
+            throw new Error(`Viewport with Id ${viewportId} is not a StackViewport.`);
+        }
+        return viewport;
+    }
+    getStackViewports() {
+        this._throwIfDestroyed();
+        const viewports = this.getViewports();
+        return viewports.filter((vp) => vp instanceof StackViewport);
+    }
+    getVolumeViewports() {
+        this._throwIfDestroyed();
+        const viewports = this.getViewports();
+        const isVolumeViewport = (viewport) => {
+            return viewport instanceof BaseVolumeViewport;
+        };
+        return viewports.filter(isVolumeViewport);
+    }
+    render() {
+        const viewports = this.getViewports();
+        const viewportIds = viewports.map((vp) => vp.id);
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    renderViewports(viewportIds) {
+        this._setViewportsToBeRenderedNextFrame(viewportIds);
+    }
+    renderViewport(viewportId) {
+        this._setViewportsToBeRenderedNextFrame([viewportId]);
+    }
+    destroy() {
+        if (this.hasBeenDestroyed) {
+            return;
+        }
+        if (!this.useCPURendering) {
+            const viewports = this._getViewportsAsArray();
+            viewports.forEach((vp) => {
+                this.offscreenMultiRenderWindow.removeRenderer(vp.id);
+            });
+            this.offscreenMultiRenderWindow.delete();
+            delete this.offscreenMultiRenderWindow;
+        }
+        this._reset();
+        renderingEngineCache.delete(this.id);
+        this.hasBeenDestroyed = true;
+    }
+    fillCanvasWithBackgroundColor(canvas, backgroundColor) {
+        const ctx = canvas.getContext('2d');
+        let fillStyle;
+        if (backgroundColor) {
+            const rgb = backgroundColor.map((f) => Math.floor(255 * f));
+            fillStyle = `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
+        }
+        else {
+            fillStyle = 'black';
+        }
+        ctx.fillStyle = fillStyle;
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+    }
+    _normalizeViewportInputEntry(viewportInputEntry) {
+        const { type, defaultOptions } = viewportInputEntry;
+        let options = defaultOptions;
+        if (!options || Object.keys(options).length === 0) {
+            options = {
+                background: [0, 0, 0],
+                orientation: null,
+                displayArea: null,
+            };
+            if (type === ViewportType.ORTHOGRAPHIC) {
+                options = {
+                    ...options,
+                    orientation: OrientationAxis.AXIAL,
+                };
+            }
+        }
+        return {
+            ...viewportInputEntry,
+            defaultOptions: options,
+        };
+    }
+    _normalizeViewportInputEntries(viewportInputEntries) {
+        const normalizedViewportInputs = [];
+        viewportInputEntries.forEach((viewportInput) => {
+            normalizedViewportInputs.push(this._normalizeViewportInputEntry(viewportInput));
+        });
+        return normalizedViewportInputs;
+    }
+    _resizeUsingCustomResizeHandler(customRenderingViewports, keepCamera = true, immediate = true) {
+        customRenderingViewports.forEach((vp) => {
+            if (typeof vp.resize === 'function') {
+                vp.resize();
+            }
+        });
+        customRenderingViewports.forEach((vp) => {
+            const prevCamera = vp.getCamera();
+            vp.resetCamera();
+            if (keepCamera) {
+                vp.setCamera(prevCamera);
+            }
+        });
+        if (immediate) {
+            this.render();
+        }
+    }
+    _removeViewport(viewportId) {
+        const viewport = this.getViewport(viewportId);
+        if (!viewport) {
+            console.warn(`viewport ${viewportId} does not exist`);
+            return;
+        }
+        this._viewports.delete(viewportId);
+    }
+    addCustomViewport(viewportInputEntry) {
+        const { element, viewportId, type, defaultOptions } = viewportInputEntry;
+        element.tabIndex = -1;
+        const canvas = getOrCreateCanvas(element);
+        const { clientWidth, clientHeight } = canvas;
+        if (canvas.width !== clientWidth || canvas.height !== clientHeight) {
+            canvas.width = clientWidth;
+            canvas.height = clientHeight;
+        }
+        const viewportInput = {
+            id: viewportId,
+            renderingEngineId: this.id,
+            element,
+            type,
+            canvas,
+            sx: 0,
+            sy: 0,
+            sWidth: clientWidth,
+            sHeight: clientHeight,
+            defaultOptions: defaultOptions || {},
+        };
+        const ViewportType = viewportTypeToViewportClass[type];
+        const viewport = new ViewportType(viewportInput);
+        this._viewports.set(viewportId, viewport);
+        const eventDetail = {
+            element,
+            viewportId,
+            renderingEngineId: this.id,
+        };
+        triggerEvent(eventTarget, Events.ELEMENT_ENABLED, eventDetail);
+    }
+    setCustomViewports(viewportInputEntries) {
+        viewportInputEntries.forEach((vpie) => {
+            this.addCustomViewport(vpie);
+        });
+    }
+    _getViewportsAsArray() {
+        return Array.from(this._viewports.values());
+    }
+    _setViewportsToBeRenderedNextFrame(viewportIds) {
+        viewportIds.forEach((viewportId) => {
+            this._needsRender.add(viewportId);
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && !this._animationFrameSet) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
+            this._animationFrameSet = true;
+        }
+    }
+    _resetViewport(viewport) {
+        const renderingEngineId = this.id;
+        const { element, canvas, id: viewportId } = viewport;
+        const eventDetail = {
+            element,
+            viewportId,
+            renderingEngineId,
+        };
+        viewport.removeWidgets();
+        triggerEvent(eventTarget, Events.ELEMENT_DISABLED, eventDetail);
+        element.removeAttribute('data-viewport-uid');
+        element.removeAttribute('data-rendering-engine-uid');
+        const context = canvas.getContext('2d');
+        context.clearRect(0, 0, canvas.width, canvas.height);
+    }
+    _clearAnimationFrame() {
+        window.cancelAnimationFrame(this._animationFrameHandle);
+        this._needsRender.clear();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+    }
+    _reset() {
+        const viewports = this._getViewportsAsArray();
+        viewports.forEach((viewport) => {
+            this._resetViewport(viewport);
+        });
+        this._clearAnimationFrame();
+        this._viewports = new Map();
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+}
+export default BaseRenderingEngine;

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

@@ -69,8 +69,11 @@ declare abstract class BaseVolumeViewport extends Viewport {
     setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
     private _setVolumeActors;
     canvasToWorld: (canvasPos: Point2) => Point3;
+    canvasToWorldSequential: (canvasPos: Point2) => Point3;
     getVtkDisplayCoords: (canvasPos: Point2) => Point3;
+    getVtkDisplayCoordsSequential: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
+    worldToCanvasSequential: (worldPos: Point3) => Point2;
     hasImageURI: (imageURI: string) => boolean;
     protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
     protected _getAcquisitionPlaneOrientation(): OrientationVectors;
@@ -86,5 +89,20 @@ declare abstract class BaseVolumeViewport extends Viewport {
     abstract resetSlabThickness(): void;
     abstract resetProperties(volumeId?: string): void;
     getAllVolumeIds(): string[];
+    private _configureRenderingPipeline;
+    protected renderingPipelineFunctions: {
+        worldToCanvas: {
+            default: (worldPos: Point3) => Point2;
+            sequential: (worldPos: Point3) => Point2;
+        };
+        canvasToWorld: {
+            default: (canvasPos: Point2) => Point3;
+            sequential: (canvasPos: Point2) => Point3;
+        };
+        getVtkDisplayCoords: {
+            default: (canvasPos: Point2) => Point3;
+            sequential: (canvasPos: Point2) => Point3;
+        };
+    };
 }
 export default BaseVolumeViewport;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -29,6 +29,7 @@ import imageIdToURI from '../utilities/imageIdToURI';
 import uuidv4 from '../utilities/uuidv4';
 import * as metaData from '../metaData';
 import { getCameraVectors } from './helpers/getCameraVectors';
+import { isSequentialRenderingEngine } from './helpers/isSequentialRenderingEngine';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
@@ -164,6 +165,28 @@ class BaseVolumeViewport extends Viewport {
             vtkCamera.setIsPerformingCoordinateTransformation?.(false);
             return [worldCoord[0], worldCoord[1], worldCoord[2]];
         };
+        this.canvasToWorldSequential = (canvasPos) => {
+            const vtkCamera = this.getVtkActiveCamera();
+            vtkCamera.setIsPerformingCoordinateTransformation?.(true);
+            const renderer = this.getRenderer();
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const { width, height } = this.canvas;
+            const aspectRatio = width / height;
+            const canvasPosWithDPR = [
+                canvasPos[0] * devicePixelRatio,
+                canvasPos[1] * devicePixelRatio,
+            ];
+            const normalizedDisplay = [
+                canvasPosWithDPR[0] / width,
+                1 - canvasPosWithDPR[1] / height,
+                0,
+            ];
+            const projCoords = renderer.normalizedDisplayToProjection(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2]);
+            const viewCoords = renderer.projectionToView(projCoords[0], projCoords[1], projCoords[2], aspectRatio);
+            const worldCoord = renderer.viewToWorld(viewCoords[0], viewCoords[1], viewCoords[2]);
+            vtkCamera.setIsPerformingCoordinateTransformation?.(false);
+            return [worldCoord[0], worldCoord[1], worldCoord[2]];
+        };
         this.getVtkDisplayCoords = (canvasPos) => {
             const devicePixelRatio = window.devicePixelRatio || 1;
             const canvasPosWithDPR = [
@@ -180,6 +203,16 @@ class BaseVolumeViewport extends Viewport {
             displayCoord[1] = size[1] - displayCoord[1];
             return [displayCoord[0], displayCoord[1], 0];
         };
+        this.getVtkDisplayCoordsSequential = (canvasPos) => {
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const canvasPosWithDPR = [
+                canvasPos[0] * devicePixelRatio,
+                canvasPos[1] * devicePixelRatio,
+            ];
+            const { height } = this.canvas;
+            const displayCoord = [canvasPosWithDPR[0], height - canvasPosWithDPR[1]];
+            return [displayCoord[0], displayCoord[1], 0];
+        };
         this.worldToCanvas = (worldPos) => {
             const vtkCamera = this.getVtkActiveCamera();
             vtkCamera.setIsPerformingCoordinateTransformation?.(true);
@@ -201,6 +234,25 @@ class BaseVolumeViewport extends Viewport {
             vtkCamera.setIsPerformingCoordinateTransformation(false);
             return canvasCoordWithDPR;
         };
+        this.worldToCanvasSequential = (worldPos) => {
+            const vtkCamera = this.getVtkActiveCamera();
+            vtkCamera.setIsPerformingCoordinateTransformation?.(true);
+            const renderer = this.getRenderer();
+            const { width, height } = this.canvas;
+            const aspectRatio = width / height;
+            const viewCoords = renderer.worldToView(worldPos[0], worldPos[1], worldPos[2]);
+            const projCoords = renderer.viewToProjection(viewCoords[0], viewCoords[1], viewCoords[2], aspectRatio);
+            const normalizedDisplay = renderer.projectionToNormalizedDisplay(projCoords[0], projCoords[1], projCoords[2]);
+            const canvasX = normalizedDisplay[0] * width;
+            const canvasY = (1 - normalizedDisplay[1]) * height;
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            const canvasCoordWithDPR = [
+                canvasX / devicePixelRatio,
+                canvasY / devicePixelRatio,
+            ];
+            vtkCamera.setIsPerformingCoordinateTransformation(false);
+            return canvasCoordWithDPR;
+        };
         this.hasImageURI = (imageURI) => {
             const volumeActors = this.getActors().filter((actorEntry) => actorIsA(actorEntry, 'vtkVolume'));
             return volumeActors.some(({ uid, referencedId }) => {
@@ -224,10 +276,25 @@ class BaseVolumeViewport extends Viewport {
             }
             return imageVolume.imageIds;
         };
+        this.renderingPipelineFunctions = {
+            worldToCanvas: {
+                default: this.worldToCanvas,
+                sequential: this.worldToCanvasSequential,
+            },
+            canvasToWorld: {
+                default: this.canvasToWorld,
+                sequential: this.canvasToWorldSequential,
+            },
+            getVtkDisplayCoords: {
+                default: this.getVtkDisplayCoords,
+                sequential: this.getVtkDisplayCoordsSequential,
+            },
+        };
         this.useCPURendering = getShouldUseCPURendering();
         if (this.useCPURendering) {
             throw new Error('VolumeViewports cannot be used whilst CPU Fallback Rendering is enabled.');
         }
+        this._configureRenderingPipeline();
         const renderer = this.getRenderer();
         const camera = vtkSlabCamera.newInstance();
         renderer.setActiveCamera(camera);
@@ -986,5 +1053,15 @@ class BaseVolumeViewport extends Viewport {
     getAllVolumeIds() {
         return Array.from(this.volumeIds);
     }
+    _configureRenderingPipeline() {
+        const renderingEngine = this.getRenderingEngine();
+        const isSequential = isSequentialRenderingEngine(renderingEngine);
+        for (const key in this.renderingPipelineFunctions) {
+            if (Object.prototype.hasOwnProperty.call(this.renderingPipelineFunctions, key)) {
+                const functions = this.renderingPipelineFunctions[key];
+                this[key] = isSequential ? functions.sequential : functions.default;
+            }
+        }
+    }
 }
 export default BaseVolumeViewport;

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

@@ -1,17 +1,10 @@
-import type IStackViewport from '../types/IStackViewport';
-import type IVolumeViewport from '../types/IVolumeViewport';
-import type { PublicViewportInput, IViewport } from '../types/IViewport';
+import type { IStackViewport, IVolumeViewport, IViewport, PublicViewportInput } from '../types';
 declare class RenderingEngine {
-    readonly id: string;
     hasBeenDestroyed: boolean;
     offscreenMultiRenderWindow: any;
-    readonly offScreenCanvasContainer: HTMLDivElement;
-    private _viewports;
-    private _needsRender;
-    private _animationFrameSet;
-    private _animationFrameHandle;
-    private useCPURendering;
+    private _implementation?;
     constructor(id?: string);
+    get id(): string;
     enableElement(viewportInputEntry: PublicViewportInput): void;
     disableElement(viewportId: string): void;
     setViewports(publicViewportInputEntries: PublicViewportInput[]): void;
@@ -21,37 +14,10 @@ declare class RenderingEngine {
     getStackViewport(viewportId: string): IStackViewport;
     getStackViewports(): IStackViewport[];
     getVolumeViewports(): IVolumeViewport[];
+    fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
     render(): void;
-    renderFrameOfReference: (FrameOfReferenceUID: string) => void;
     renderViewports(viewportIds: string[]): void;
     renderViewport(viewportId: string): void;
     destroy(): void;
-    fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
-    private _normalizeViewportInputEntry;
-    private _normalizeViewportInputEntries;
-    private _resizeUsingCustomResizeHandler;
-    private _resizeVTKViewports;
-    private enableVTKjsDrivenViewport;
-    private _removeViewport;
-    private addVtkjsDrivenViewport;
-    private addCustomViewport;
-    private setCustomViewports;
-    private setVtkjsDrivenViewports;
-    private _resizeOffScreenCanvas;
-    private _resize;
-    private _getViewportCoordsOnOffScreenCanvas;
-    private _getViewportsAsArray;
-    private _setViewportsToBeRenderedNextFrame;
-    private _render;
-    private _renderFlaggedViewports;
-    private performVtkDrawCall;
-    private renderViewportUsingCustomOrVtkPipeline;
-    private _renderViewportFromVtkCanvasToOnscreenCanvas;
-    private _resetViewport;
-    private _clearAnimationFrame;
-    private _reset;
-    private _throwIfDestroyed;
-    _downloadOffScreenCanvas(): void;
-    _debugRender(): void;
 }
 export default RenderingEngine;