@cornerstonejs/core 3.29.1 → 3.29.3

package/dist/esm/RenderingEngine/StandardRenderingEngine.js

@@ -0,0 +1,285 @@
+import BaseRenderingEngine, { VIEWPORT_MIN_SIZE } from './BaseRenderingEngine';
+import Events from '../enums/Events';
+import eventTarget from '../eventTarget';
+import triggerEvent from '../utilities/triggerEvent';
+import ViewportType from '../enums/ViewportType';
+import VolumeViewport from './VolumeViewport';
+import StackViewport from './StackViewport';
+import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
+import getOrCreateCanvas from './helpers/getOrCreateCanvas';
+import VolumeViewport3D from './VolumeViewport3D';
+class StandardRenderingEngine extends BaseRenderingEngine {
+    constructor() {
+        super(...arguments);
+        this._renderFlaggedViewports = () => {
+            this._throwIfDestroyed();
+            if (!this.useCPURendering) {
+                this.performVtkDrawCall();
+            }
+            const viewports = this._getViewportsAsArray();
+            const eventDetailArray = [];
+            for (let i = 0; i < viewports.length; i++) {
+                const viewport = viewports[i];
+                if (this._needsRender.has(viewport.id)) {
+                    const eventDetail = this.renderViewportUsingCustomOrVtkPipeline(viewport);
+                    eventDetailArray.push(eventDetail);
+                    viewport.setRendered();
+                    this._needsRender.delete(viewport.id);
+                    if (this._needsRender.size === 0) {
+                        break;
+                    }
+                }
+            }
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+            eventDetailArray.forEach((eventDetail) => {
+                if (!eventDetail?.element) {
+                    return;
+                }
+                triggerEvent(eventDetail.element, Events.IMAGE_RENDERED, eventDetail);
+            });
+        };
+    }
+    enableVTKjsDrivenViewport(viewportInputEntry) {
+        const viewports = this._getViewportsAsArray();
+        const viewportsDrivenByVtkJs = viewports.filter((vp) => viewportTypeUsesCustomRenderingPipeline(vp.type) === false);
+        const canvasesDrivenByVtkJs = viewportsDrivenByVtkJs.map((vp) => vp.canvas);
+        const canvas = getOrCreateCanvas(viewportInputEntry.element);
+        canvasesDrivenByVtkJs.push(canvas);
+        const { offScreenCanvasWidth, offScreenCanvasHeight } = this._resizeOffScreenCanvas(canvasesDrivenByVtkJs);
+        const xOffset = this._resize(viewportsDrivenByVtkJs, offScreenCanvasWidth, offScreenCanvasHeight);
+        const internalViewportEntry = { ...viewportInputEntry, canvas };
+        this.addVtkjsDrivenViewport(internalViewportEntry, {
+            offScreenCanvasWidth,
+            offScreenCanvasHeight,
+            xOffset,
+        });
+    }
+    addVtkjsDrivenViewport(viewportInputEntry, offscreenCanvasProperties) {
+        const { element, canvas, viewportId, type, defaultOptions } = viewportInputEntry;
+        element.tabIndex = -1;
+        const { offScreenCanvasWidth, offScreenCanvasHeight, xOffset } = offscreenCanvasProperties;
+        const { sxStartDisplayCoords, syStartDisplayCoords, sxEndDisplayCoords, syEndDisplayCoords, sx, sy, sWidth, sHeight, } = this._getViewportCoordsOnOffScreenCanvas(viewportInputEntry, offScreenCanvasWidth, offScreenCanvasHeight, xOffset);
+        this.offscreenMultiRenderWindow.addRenderer({
+            viewport: [
+                sxStartDisplayCoords,
+                syStartDisplayCoords,
+                sxEndDisplayCoords,
+                syEndDisplayCoords,
+            ],
+            id: viewportId,
+            background: defaultOptions.background
+                ? defaultOptions.background
+                : [0, 0, 0],
+        });
+        const viewportInput = {
+            id: viewportId,
+            element,
+            renderingEngineId: this.id,
+            type,
+            canvas,
+            sx,
+            sy,
+            sWidth,
+            sHeight,
+            defaultOptions: defaultOptions || {},
+        };
+        let viewport;
+        if (type === ViewportType.STACK) {
+            viewport = new StackViewport(viewportInput);
+        }
+        else if (type === ViewportType.ORTHOGRAPHIC ||
+            type === ViewportType.PERSPECTIVE) {
+            viewport = new VolumeViewport(viewportInput);
+        }
+        else if (type === ViewportType.VOLUME_3D) {
+            viewport = new VolumeViewport3D(viewportInput);
+        }
+        else {
+            throw new Error(`Viewport Type ${type} is not supported`);
+        }
+        this._viewports.set(viewportId, viewport);
+        const eventDetail = {
+            element,
+            viewportId,
+            renderingEngineId: this.id,
+        };
+        if (!viewport.suppressEvents) {
+            triggerEvent(eventTarget, Events.ELEMENT_ENABLED, eventDetail);
+        }
+    }
+    setVtkjsDrivenViewports(viewportInputEntries) {
+        if (viewportInputEntries.length) {
+            const vtkDrivenCanvases = viewportInputEntries.map((vp) => getOrCreateCanvas(vp.element));
+            vtkDrivenCanvases.forEach((canvas) => {
+                const devicePixelRatio = window.devicePixelRatio || 1;
+                const rect = canvas.getBoundingClientRect();
+                canvas.width = rect.width * devicePixelRatio;
+                canvas.height = rect.height * devicePixelRatio;
+            });
+            const { offScreenCanvasWidth, offScreenCanvasHeight } = this._resizeOffScreenCanvas(vtkDrivenCanvases);
+            let xOffset = 0;
+            for (let i = 0; i < viewportInputEntries.length; i++) {
+                const vtkDrivenViewportInputEntry = viewportInputEntries[i];
+                const canvas = vtkDrivenCanvases[i];
+                const internalViewportEntry = {
+                    ...vtkDrivenViewportInputEntry,
+                    canvas,
+                };
+                this.addVtkjsDrivenViewport(internalViewportEntry, {
+                    offScreenCanvasWidth,
+                    offScreenCanvasHeight,
+                    xOffset,
+                });
+                xOffset += canvas.width;
+            }
+        }
+    }
+    _resizeVTKViewports(vtkDrivenViewports, keepCamera = true, immediate = true) {
+        const canvasesDrivenByVtkJs = vtkDrivenViewports.map((vp) => {
+            return getOrCreateCanvas(vp.element);
+        });
+        canvasesDrivenByVtkJs.forEach((canvas) => {
+            const devicePixelRatio = window.devicePixelRatio || 1;
+            canvas.width = canvas.clientWidth * devicePixelRatio;
+            canvas.height = canvas.clientHeight * devicePixelRatio;
+        });
+        if (canvasesDrivenByVtkJs.length) {
+            const { offScreenCanvasWidth, offScreenCanvasHeight } = this._resizeOffScreenCanvas(canvasesDrivenByVtkJs);
+            this._resize(vtkDrivenViewports, offScreenCanvasWidth, offScreenCanvasHeight);
+        }
+        vtkDrivenViewports.forEach((vp) => {
+            const prevCamera = vp.getCamera();
+            const rotation = vp.getRotation();
+            const { flipHorizontal } = prevCamera;
+            vp.resetCameraForResize();
+            const displayArea = vp.getDisplayArea();
+            if (keepCamera) {
+                if (displayArea) {
+                    if (flipHorizontal) {
+                        vp.setCamera({ flipHorizontal });
+                    }
+                    if (rotation) {
+                        vp.setViewPresentation({ rotation });
+                    }
+                }
+                else {
+                    vp.setCamera(prevCamera);
+                }
+            }
+        });
+        if (immediate) {
+            this.render();
+        }
+    }
+    performVtkDrawCall() {
+        const { offscreenMultiRenderWindow } = this;
+        const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+        const renderers = offscreenMultiRenderWindow.getRenderers();
+        if (!renderers.length) {
+            return;
+        }
+        for (let i = 0; i < renderers.length; i++) {
+            const { renderer, id } = renderers[i];
+            if (this._needsRender.has(id)) {
+                renderer.setDraw(true);
+            }
+            else {
+                renderer.setDraw(false);
+            }
+        }
+        renderWindow.render();
+        for (let i = 0; i < renderers.length; i++) {
+            renderers[i].renderer.setDraw(false);
+        }
+    }
+    renderViewportUsingCustomOrVtkPipeline(viewport) {
+        let eventDetail;
+        if (viewport.sWidth < VIEWPORT_MIN_SIZE ||
+            viewport.sHeight < VIEWPORT_MIN_SIZE) {
+            console.warn('Viewport is too small', viewport.sWidth, viewport.sHeight);
+            return;
+        }
+        if (viewportTypeUsesCustomRenderingPipeline(viewport.type) === true) {
+            eventDetail =
+                viewport.customRenderViewportToCanvas();
+        }
+        else {
+            if (this.useCPURendering) {
+                throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
+            }
+            const { offscreenMultiRenderWindow } = this;
+            const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
+            const context = openGLRenderWindow.get3DContext();
+            const offScreenCanvas = context.canvas;
+            eventDetail = this._renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas);
+        }
+        return eventDetail;
+    }
+    _renderViewportFromVtkCanvasToOnscreenCanvas(viewport, offScreenCanvas) {
+        const { element, canvas, sx, sy, sWidth, sHeight, id: viewportId, renderingEngineId, suppressEvents, } = viewport;
+        const { width: dWidth, height: dHeight } = canvas;
+        const onScreenContext = canvas.getContext('2d');
+        onScreenContext.drawImage(offScreenCanvas, sx, sy, sWidth, sHeight, 0, 0, dWidth, dHeight);
+        return {
+            element,
+            suppressEvents,
+            viewportId,
+            renderingEngineId,
+            viewportStatus: viewport.viewportStatus,
+        };
+    }
+    _resizeOffScreenCanvas(canvasesDrivenByVtkJs) {
+        const { offScreenCanvasContainer, offscreenMultiRenderWindow } = this;
+        const offScreenCanvasHeight = Math.max(...canvasesDrivenByVtkJs.map((canvas) => canvas.height));
+        let offScreenCanvasWidth = 0;
+        canvasesDrivenByVtkJs.forEach((canvas) => {
+            offScreenCanvasWidth += canvas.width;
+        });
+        offScreenCanvasContainer.width = offScreenCanvasWidth;
+        offScreenCanvasContainer.height = offScreenCanvasHeight;
+        offscreenMultiRenderWindow.resize();
+        return { offScreenCanvasWidth, offScreenCanvasHeight };
+    }
+    _resize(viewportsDrivenByVtkJs, offScreenCanvasWidth, offScreenCanvasHeight) {
+        let _xOffset = 0;
+        for (let i = 0; i < viewportsDrivenByVtkJs.length; i++) {
+            const viewport = viewportsDrivenByVtkJs[i];
+            const { sxStartDisplayCoords, syStartDisplayCoords, sxEndDisplayCoords, syEndDisplayCoords, sx, sy, sWidth, sHeight, } = this._getViewportCoordsOnOffScreenCanvas(viewport, offScreenCanvasWidth, offScreenCanvasHeight, _xOffset);
+            _xOffset += viewport.canvas.width;
+            viewport.sx = sx;
+            viewport.sy = sy;
+            viewport.sWidth = sWidth;
+            viewport.sHeight = sHeight;
+            const renderer = this.offscreenMultiRenderWindow.getRenderer(viewport.id);
+            renderer.setViewport([
+                sxStartDisplayCoords,
+                syStartDisplayCoords,
+                sxEndDisplayCoords,
+                syEndDisplayCoords,
+            ]);
+        }
+        return _xOffset;
+    }
+    _getViewportCoordsOnOffScreenCanvas(viewport, offScreenCanvasWidth, offScreenCanvasHeight, _xOffset) {
+        const { canvas } = viewport;
+        const { width: sWidth, height: sHeight } = canvas;
+        const sx = _xOffset;
+        const sy = 0;
+        const sxStartDisplayCoords = sx / offScreenCanvasWidth;
+        const syStartDisplayCoords = sy + (offScreenCanvasHeight - sHeight) / offScreenCanvasHeight;
+        const sWidthDisplayCoords = sWidth / offScreenCanvasWidth;
+        const sHeightDisplayCoords = sHeight / offScreenCanvasHeight;
+        return {
+            sxStartDisplayCoords,
+            syStartDisplayCoords,
+            sxEndDisplayCoords: sxStartDisplayCoords + sWidthDisplayCoords,
+            syEndDisplayCoords: syStartDisplayCoords + sHeightDisplayCoords,
+            sx,
+            sy,
+            sWidth,
+            sHeight,
+        };
+    }
+}
+export default StandardRenderingEngine;

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

@@ -0,0 +1 @@
+export declare function isSequentialRenderingEngine(renderingEngine: any): boolean;

package/dist/esm/RenderingEngine/helpers/isSequentialRenderingEngine.js

@@ -0,0 +1,6 @@
+import { getConfiguration } from '../../init';
+import { RenderingEngineModeEnum } from '../../enums';
+export function isSequentialRenderingEngine(renderingEngine) {
+    const config = getConfiguration();
+    return (config?.rendering?.renderingEngineMode === RenderingEngineModeEnum.Next);
+}

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

@@ -1,8 +1,11 @@
 import RenderingEngine from './RenderingEngine';
+import BaseRenderingEngine from './BaseRenderingEngine';
+import StandardRenderingEngine from './StandardRenderingEngine';
+import SequentialRenderingEngine from './SequentialRenderingEngine';
 import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
 export default RenderingEngine;

package/dist/esm/RenderingEngine/index.js

@@ -1,8 +1,11 @@
 import RenderingEngine from './RenderingEngine';
+import BaseRenderingEngine from './BaseRenderingEngine';
+import StandardRenderingEngine from './StandardRenderingEngine';
+import SequentialRenderingEngine from './SequentialRenderingEngine';
 import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
 export default RenderingEngine;

package/dist/esm/enums/RenderingEngineModeEnum.d.ts

@@ -0,0 +1,5 @@
+declare enum RenderingEngineModeEnum {
+    Standard = "standard",
+    Next = "next"
+}
+export default RenderingEngineModeEnum;

package/dist/esm/enums/RenderingEngineModeEnum.js

@@ -0,0 +1,6 @@
+var RenderingEngineModeEnum;
+(function (RenderingEngineModeEnum) {
+    RenderingEngineModeEnum["Standard"] = "standard";
+    RenderingEngineModeEnum["Next"] = "next";
+})(RenderingEngineModeEnum || (RenderingEngineModeEnum = {}));
+export default RenderingEngineModeEnum;

package/dist/esm/enums/index.d.ts

@@ -16,4 +16,5 @@ import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };
+import RenderingEngineModeEnum from './RenderingEngineModeEnum';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/enums/index.js

@@ -16,4 +16,5 @@ import * as VideoEnums from './VideoEnums';
 import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, };
+import RenderingEngineModeEnum from './RenderingEngineModeEnum';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/index.d.ts

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -37,4 +37,4 @@ import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerst
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import * as Enums from './enums';
 import * as CONSTANTS from './constants';
 import { Events } from './enums';
-import RenderingEngine from './RenderingEngine';
+import RenderingEngine, { BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, } from './RenderingEngine';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor';
 import createVolumeMapper, { convertMapperToNotSharedMapper, } from './RenderingEngine/helpers/createVolumeMapper';
 export * from './RenderingEngine/helpers/getOrCreateCanvas';
@@ -34,4 +34,4 @@ import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStre
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, RenderingEngine, BaseRenderingEngine, StandardRenderingEngine, SequentialRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.js

@@ -3,6 +3,7 @@ let csRenderInitialized = false;
 import deepMerge from './utilities/deepMerge';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
 import { getSupportedTextureFormats } from './utilities/textureSupport';
+import { RenderingEngineModeEnum } from './enums';
 const defaultConfig = {
     gpuTier: { tier: 2 },
     isMobile: false,
@@ -10,6 +11,7 @@ const defaultConfig = {
         useCPURendering: false,
         preferSizeOverAccuracy: false,
         strictZSpacingForVolumeViewport: true,
+        renderingEngineMode: RenderingEngineModeEnum.Next,
     },
     peerImport: (moduleId) => null,
 };

package/dist/esm/types/Cornerstone3DConfig.d.ts

@@ -1,12 +1,14 @@
+import type { RenderingEngineModeType } from '../types';
 interface Cornerstone3DConfig {
-    gpuTier: {
-        tier: number;
+    gpuTier?: {
+        tier?: number;
     };
-    isMobile: boolean;
-    rendering: {
-        preferSizeOverAccuracy: boolean;
-        useCPURendering: boolean;
-        strictZSpacingForVolumeViewport: boolean;
+    isMobile?: boolean;
+    rendering?: {
+        preferSizeOverAccuracy?: boolean;
+        useCPURendering?: boolean;
+        strictZSpacingForVolumeViewport?: boolean;
+        renderingEngineMode?: RenderingEngineModeType;
     };
     peerImport?: (moduleId: string) => Promise<any>;
 }

package/dist/esm/types/IRenderingEngine.d.ts

@@ -1,3 +1,3 @@
-import type RenderingEngine from '../RenderingEngine/RenderingEngine';
+import type { RenderingEngine } from '../RenderingEngine';
 type IRenderingEngine = RenderingEngine;
 export type { IRenderingEngine as default };

package/dist/esm/types/RenderingEngineMode.d.ts

@@ -0,0 +1,2 @@
+type RenderingEngineModeType = 'standard' | 'next';
+export type { RenderingEngineModeType };

package/dist/esm/types/index.d.ts

@@ -101,4 +101,5 @@ import type { IBaseVolumeViewport } from './IBaseVolumeViewport';
 import type ScrollOptions from './ScrollOptions';
 import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
-export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, };
+import type { RenderingEngineModeType } from './RenderingEngineMode';
+export type { Cornerstone3DConfig, ICamera, IStackViewport, IVideoViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, ImagePlaneModuleMetadata, SopCommonModuleMetadata, ImagePixelModuleMetadata, PatientStudyModuleMetadata, TransferSyntaxMetadata, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.29.1";
+export declare const version = "3.29.3";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.29.1';
+export const version = '3.29.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.29.1",
+  "version": "3.29.3",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "09e8e30f6ee9c0ba652a298c721f4022f21c381d"
+  "gitHead": "b3073ebc138e6bf613b6e4b2b66d6d8d7d7cfb89"
 }