@cornerstonejs/core 5.2.2 → 5.3.0

package/dist/esm/RenderingEngine/ContextPoolRenderingEngine.js

@@ -43,7 +43,7 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
         if (!this.contextPool) {
             const { rendering } = getConfiguration();
             const { webGlContextCount } = rendering;
-            this.contextPool = new WebGLContextPool(webGlContextCount);
+            this.contextPool = new WebGLContextPool(webGlContextCount, this.id);
         }
         return this.contextPool;
     }

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

@@ -60,6 +60,7 @@ declare abstract class GenericViewport<TViewState extends object, TDataPresentat
     setRendered(): void;
     setNeedsRender(): void;
     abstract render(): void;
+    updateRenderingPipeline(): void;
     resize(): void;
     resetViewState(_options?: unknown): boolean;
     resizeForRenderingEngine({ keepCamera, }?: RenderingEngineResizeOptions): void;

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

@@ -161,6 +161,8 @@ class GenericViewport {
     setNeedsRender() {
         this.viewportStatus = ViewportStatus.NEEDS_RENDER;
     }
+    updateRenderingPipeline() {
+    }
     resize() {
         if (this.isDestroyed) {
             return;
@@ -190,10 +192,6 @@ class GenericViewport {
         const path = this.renderPathResolver.resolve(this.type, data, options);
         const renderPath = path.createRenderPath();
         const ctx = path.selectContext?.(this.renderContext) ?? this.renderContext;
-        const existing = this.bindings.get(displaySetId);
-        if (existing) {
-            existing.removeData();
-        }
         const attachment = await renderPath.addData(ctx, data, options);
         if (shouldIgnore?.()) {
             attachment.removeData();
@@ -204,7 +202,7 @@ class GenericViewport {
             throw new Error('Viewport has been destroyed');
         }
         const current = this.bindings.get(displaySetId);
-        if (current && current !== existing) {
+        if (current) {
             current.removeData();
         }
         const role = options.role ?? 'overlay';

package/dist/esm/RenderingEngine/GenericViewport/Planar/CpuImageSliceRenderPath.js

@@ -33,7 +33,7 @@ export class CpuImageSliceRenderPath {
             getImageData: () => this.getImageData(rendering),
         }, payload.image);
         compatibilityActor.setVisibility(true);
-        const defaultViewport = getDefaultViewport(ctx.cpu.canvas, payload.image);
+        const defaultViewport = getDefaultViewport(ctx.cpu.canvas, payload.image, getCPUFallbackViewportModality(payload.image));
         defaultViewport.displayedArea = resolvePlanarCpuImageDisplayedArea(payload.image);
         const enabledElement = {
             canvas: ctx.cpu.canvas,
@@ -196,7 +196,7 @@ export class CpuImageSliceRenderPath {
             rendering,
             viewState: camera,
         });
-        rendering.fitScale = getCPUFallbackScalarScale(getDefaultViewport(rendering.enabledElement.canvas, image).scale);
+        rendering.fitScale = getCPUFallbackScalarScale(getDefaultViewport(rendering.enabledElement.canvas, image, getCPUFallbackViewportModality(image)).scale);
         rendering.renderingInvalidated = true;
         if (projection) {
             applyPresentationState(rendering, projection.presentation, projection.resolvedICamera);
@@ -359,6 +359,10 @@ function worldToCPUImageDrawPoint(enabledElement, worldPos) {
 function markCpuImagePreScaled(image) {
     image.isPreScaled = image.preScale?.scaled;
 }
+function getCPUFallbackViewportModality(image) {
+    return (image.preScale?.scalingParameters?.modality ||
+        metaData.get(MetadataModules.GENERAL_SERIES, image.imageId)?.modality);
+}
 export function buildPlanarImageData(image, frameOfReferenceUID) {
     const metadata = getImageDataMetadata(image);
     const { dimensions, direction, modality, origin, spacing } = metadata;
@@ -428,7 +432,7 @@ async function updateRenderedImage(args) {
     const enabledElement = rendering.enabledElement;
     markCpuImagePreScaled(image);
     const camera = ctx.viewport.getViewState();
-    const defaultViewport = getDefaultViewport(ctx.cpu.canvas, image);
+    const defaultViewport = getDefaultViewport(ctx.cpu.canvas, image, getCPUFallbackViewportModality(image));
     const previousViewport = enabledElement.viewport;
     defaultViewport.displayedArea = resolvePlanarCpuImageDisplayedArea(image);
     enabledElement.image = image;

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarRenderPathDecisionService.d.ts

@@ -1,6 +1,6 @@
+import { RenderBackend } from '../../../enums/index.js';
+import type { RenderBackendValue } from '../../../enums/index.js';
 import type { PlanarViewState, PlanarEffectiveRenderMode, PlanarOrientation, PlanarRegisteredDataSet } from './PlanarViewportTypes.js';
-export declare const DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD: number;
-export declare const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD: number;
 export interface SelectedPlanarRenderPath {
     acquisitionOrientation?: PlanarViewState['orientation'];
     renderMode: PlanarEffectiveRenderMode;
@@ -8,22 +8,16 @@ export interface SelectedPlanarRenderPath {
 }
 export interface PlanarRenderPathDecisionOptions {
     orientation?: PlanarOrientation;
-    cpuThresholds?: {
-        image?: number;
-        volume?: number;
-    };
     useSliceRendering?: boolean;
-    webGLAvailable?: boolean;
+    renderBackend?: RenderBackend | RenderBackendValue;
 }
 export declare class PlanarRenderPathDecisionService {
     select(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;
     canRender(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): boolean;
     private selectImageRenderMode;
     private selectVolumeRenderMode;
-    private shouldUseCPUForImage;
-    private shouldUseCPUForVolume;
+    private resolveBackend;
 }
 export declare const defaultPlanarRenderPathDecisionService: PlanarRenderPathDecisionService;
 export declare function selectPlanarRenderPath(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;
 export declare function getPlanarAcquisitionOrientation(imageIds: string[]): PlanarViewState['orientation'] | undefined;
-export declare function shouldUseCPU(imageIds: string[], threshold?: number): boolean;

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarRenderPathDecisionService.js

@@ -1,13 +1,11 @@
 import { vec3 } from 'gl-matrix';
 import cache from '../../../cache/cache.js';
-import { OrientationAxis } from '../../../enums/index.js';
-import { getConfiguration, getShouldUseCPURendering } from '../../../init.js';
+import { OrientationAxis, RenderBackend } from '../../../enums/index.js';
+import { getEffectiveRenderBackend } from '../../../init.js';
 import * as metaData from '../../../metaData.js';
 import { ActorRenderMode } from '../../../types/index.js';
 import { isValidVolume } from '../../../utilities/isValidVolume.js';
 import { getOrientationFromScanAxisNormal } from '../../helpers/getCameraVectors.js';
-export const DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD = 64 * 1024 * 1024;
-export const DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD = Number.POSITIVE_INFINITY;
 export class PlanarRenderPathDecisionService {
     select(dataSet, options = {}) {
         if (!dataSet.imageIds.length) {
@@ -31,7 +29,7 @@ export class PlanarRenderPathDecisionService {
         return {
             acquisitionOrientation,
             renderMode: useVolumePath
-                ? this.selectVolumeRenderMode(dataSet, options)
+                ? this.selectVolumeRenderMode(options)
                 : this.selectImageRenderMode(options),
             volumeId,
         };
@@ -57,29 +55,17 @@ export class PlanarRenderPathDecisionService {
         return true;
     }
     selectImageRenderMode(options) {
-        return this.shouldUseCPUForImage(options)
+        return this.resolveBackend(options) === RenderBackend.CPU
             ? ActorRenderMode.CPU_IMAGE
             : ActorRenderMode.VTK_IMAGE;
     }
-    selectVolumeRenderMode(dataSet, options) {
-        return this.shouldUseCPUForVolume(dataSet, options)
+    selectVolumeRenderMode(options) {
+        return this.resolveBackend(options) === RenderBackend.CPU
             ? ActorRenderMode.CPU_VOLUME
             : ActorRenderMode.VTK_VOLUME_SLICE;
     }
-    shouldUseCPUForImage(options) {
-        if (options.webGLAvailable === false) {
-            return true;
-        }
-        return getShouldUseCPURendering();
-    }
-    shouldUseCPUForVolume(dataSet, options) {
-        if (options.webGLAvailable === false) {
-            return true;
-        }
-        const configuredCpuThresholds = getConfiguredPlanarCpuThresholds();
-        return shouldUseCPU(dataSet.imageIds, options.cpuThresholds?.volume ??
-            configuredCpuThresholds?.volume ??
-            DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD);
+    resolveBackend(options) {
+        return getEffectiveRenderBackend(options.renderBackend);
     }
 }
 export const defaultPlanarRenderPathDecisionService = new PlanarRenderPathDecisionService();
@@ -112,30 +98,6 @@ export function getPlanarAcquisitionOrientation(imageIds) {
     }
     return orientation;
 }
-export function shouldUseCPU(imageIds, threshold = DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD) {
-    if (getShouldUseCPURendering()) {
-        return true;
-    }
-    const imageId = imageIds[0];
-    if (!imageId) {
-        return false;
-    }
-    const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-    const rows = imagePlaneModule?.rows;
-    const columns = imagePlaneModule?.columns;
-    if (!isPositiveSafeInteger(rows) || !isPositiveSafeInteger(columns)) {
-        return false;
-    }
-    if (!Number.isFinite(threshold)) {
-        return false;
-    }
-    const normalizedThreshold = Math.trunc(threshold);
-    if (!Number.isSafeInteger(normalizedThreshold) || normalizedThreshold < 0) {
-        return false;
-    }
-    return (BigInt(rows) * BigInt(columns) * BigInt(imageIds.length) >=
-        BigInt(normalizedThreshold));
-}
 function getVolumeId(dataSet) {
     return dataSet.volumeId || cache.generateVolumeId(dataSet.imageIds);
 }
@@ -154,9 +116,3 @@ function isVolumeBackedDataSet(dataSet, isAcquisitionPath) {
     }
     return !isAcquisitionPath && supportsVolumeRendering(dataSet);
 }
-function isPositiveSafeInteger(value) {
-    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
-}
-function getConfiguredPlanarCpuThresholds() {
-    return getConfiguration().rendering?.planar?.cpuThresholds;
-}

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewport.d.ts

@@ -35,6 +35,9 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     private resolvedViewCacheRevision;
     private cachedCanvasDimensions?;
     private setDataRequestId;
+    private renderPipelineSwapId;
+    private readonly lastRenderPathErrorByDataId;
+    private readonly mountOptionsByDataId;
     static get useCustomRenderingPipeline(): boolean;
     constructor(args: PlanarViewportInput);
     setDisplaySets(...entries: Array<{
@@ -130,6 +133,9 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     protected onDestroy(): void;
     protected modified(previousCamera?: ICamera): void;
     protected renderBindings(): boolean;
+    updateRenderingPipeline(): void;
+    private applyRenderingPipelineUpdate;
+    private reportRenderPathError;
     private requestRenderingEngineRender;
     private setRenderModeVisibility;
     protected createLegacyCompatibilityHost(): {
@@ -168,6 +174,7 @@ declare class PlanarViewport extends GenericViewport<PlanarViewState, PlanarData
     private isSegmentationOverlayBinding;
     private getDataSet;
     private loadPlanarData;
+    private getInheritedOverlayRenderBackend;
     private applyLoadedPlanarViewState;
     private createInitialVolumeSliceState;
     private resolveRequestedOrientation;

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewport.js

@@ -1,4 +1,4 @@
-import { Events, OrientationAxis, ViewportStatus, ViewportType, VOILUTFunctionType, } from '../../../enums/index.js';
+import { Events, OrientationAxis, RenderBackend, ViewportStatus, ViewportType, VOILUTFunctionType, } from '../../../enums/index.js';
 import { ActorRenderMode } from '../../../types/index.js';
 import { isImageActor } from '../../../utilities/actorCheck.js';
 import cache from '../../../cache/cache.js';
@@ -7,6 +7,7 @@ import imageIdToURI from '../../../utilities/imageIdToURI.js';
 import { getImageDataMetadata } from '../../../utilities/getImageDataMetadata.js';
 import genericViewportDisplaySetMetadataProvider from '../../../utilities/genericViewportDisplaySetMetadataProvider.js';
 import triggerEvent from '../../../utilities/triggerEvent.js';
+import eventTarget from '../../../eventTarget.js';
 import getMinMax from '../../../utilities/getMinMax.js';
 import renderingEngineCache from '../../renderingEngineCache.js';
 import { getCameraVectors } from '../../helpers/getCameraVectors.js';
@@ -35,6 +36,9 @@ class PlanarViewport extends GenericViewport {
         this.suppressEvents = false;
         this.resolvedViewCacheRevision = 0;
         this.setDataRequestId = 0;
+        this.renderPipelineSwapId = 0;
+        this.lastRenderPathErrorByDataId = new Map();
+        this.mountOptionsByDataId = new Map();
         this.renderingEngineId = args.renderingEngineId;
         this.canvas = args.canvas;
         this.sWidth = args.sWidth;
@@ -200,6 +204,7 @@ class PlanarViewport extends GenericViewport {
         if (!added) {
             return;
         }
+        this.mountOptionsByDataId.set(dataId, resolvedOptions);
         this.clearResolvedViewCache();
         this.setDefaultDataPresentation(dataId, {
             visible: true,
@@ -215,6 +220,8 @@ class PlanarViewport extends GenericViewport {
     }
     removeData(dataId) {
         this.clearResolvedViewCache();
+        this.mountOptionsByDataId.delete(dataId);
+        this.lastRenderPathErrorByDataId.delete(dataId);
         super.removeData(dataId);
         this.mountedData.handleRemovedData(dataId);
         if (!this.isDestroyed && this.getCurrentBinding()) {
@@ -764,17 +771,106 @@ class PlanarViewport extends GenericViewport {
         }
         let renderedByAdapter = false;
         const sourceBinding = this.getCurrentBinding();
-        sourceBinding?.render?.();
-        renderedByAdapter = renderedByAdapter || Boolean(sourceBinding?.render);
-        for (const binding of this.bindings.values()) {
+        const renderBinding = (binding, dataId) => {
+            if (!binding.render) {
+                return;
+            }
+            renderedByAdapter = true;
+            try {
+                binding.render();
+                this.lastRenderPathErrorByDataId.delete(dataId);
+            }
+            catch (error) {
+                this.reportRenderPathError(error, dataId);
+            }
+        };
+        for (const [dataId, binding] of this.bindings.entries()) {
             if (binding === sourceBinding) {
-                continue;
+                renderBinding(binding, dataId);
+            }
+        }
+        for (const [dataId, binding] of this.bindings.entries()) {
+            if (binding !== sourceBinding) {
+                renderBinding(binding, dataId);
             }
-            binding.render?.();
-            renderedByAdapter = renderedByAdapter || Boolean(binding.render);
         }
         return renderedByAdapter;
     }
+    updateRenderingPipeline() {
+        void this.applyRenderingPipelineUpdate();
+    }
+    async applyRenderingPipelineUpdate() {
+        if (this.isDestroyed) {
+            return;
+        }
+        const swapId = ++this.renderPipelineSwapId;
+        const isStale = () => swapId !== this.renderPipelineSwapId || this.isDestroyed;
+        let changed = false;
+        const sourceBinding = this.getCurrentBinding();
+        const bindingEntries = Array.from(this.bindings.entries());
+        const orderedEntries = [
+            ...bindingEntries.filter(([, binding]) => binding === sourceBinding),
+            ...bindingEntries.filter(([, binding]) => binding !== sourceBinding),
+        ];
+        for (const [dataId, binding] of orderedEntries) {
+            if (isStale()) {
+                return;
+            }
+            if (this.bindings.get(dataId) !== binding) {
+                continue;
+            }
+            const options = this.mountOptionsByDataId.get(dataId) ?? {};
+            try {
+                const { data, selectedPath } = await this.loadPlanarData(dataId, {
+                    ...options,
+                    role: binding.role,
+                });
+                if (isStale() || this.bindings.get(dataId) !== binding) {
+                    continue;
+                }
+                if (selectedPath.renderMode === binding.rendering.renderMode) {
+                    continue;
+                }
+                const added = await this.addLoadedData(dataId, data, {
+                    renderMode: selectedPath.renderMode,
+                    role: binding.role,
+                }, () => isStale() || this.bindings.get(dataId) !== binding);
+                changed = changed || added;
+            }
+            catch (error) {
+                this.reportRenderPathError(error, dataId);
+            }
+        }
+        if (isStale() || !changed) {
+            return;
+        }
+        const sourceRenderMode = this.getCurrentPlanarRendering()?.renderMode;
+        if (sourceRenderMode) {
+            this.renderContext.display.activateRenderMode(sourceRenderMode);
+        }
+        this.clearResolvedViewCache();
+        this.updateBindingsCameraState();
+        this.render();
+        triggerEvent(eventTarget, Events.RENDERING_PIPELINE_CHANGED, {
+            renderingEngineId: this.renderingEngineId,
+            viewportId: this.id,
+        });
+    }
+    reportRenderPathError(error, dataId) {
+        const message = error instanceof Error ? error.message : String(error);
+        const errorKey = dataId ?? '';
+        if (this.lastRenderPathErrorByDataId.get(errorKey) === message) {
+            return;
+        }
+        this.lastRenderPathErrorByDataId.set(errorKey, message);
+        console.error('[PlanarViewport] Render path error', dataId ?? '', error);
+        triggerEvent(eventTarget, Events.RENDER_PATH_ERROR, {
+            renderingEngineId: this.renderingEngineId,
+            viewportId: this.id,
+            dataId,
+            error,
+        });
+    }
     requestRenderingEngineRender() {
         const renderingEngine = renderingEngineCache.get(this.renderingEngineId);
         if (renderingEngine) {
@@ -927,8 +1023,8 @@ class PlanarViewport extends GenericViewport {
         const resolvedOrientation = this.resolveRequestedOrientation(options.orientation);
         const selectedPath = selectPlanarRenderPath(dataSet, {
             orientation: resolvedOrientation,
-            cpuThresholds: options.cpuThresholds,
-            webGLAvailable: options.forceCPU ? false : undefined,
+            renderBackend: options.renderBackend ??
+                this.getInheritedOverlayRenderBackend(options.role),
         });
         const data = await this.dataProvider.load(dataId, {
             acquisitionOrientation: selectedPath.acquisitionOrientation,
@@ -942,6 +1038,21 @@ class PlanarViewport extends GenericViewport {
             resolvedOrientation,
         };
     }
+    getInheritedOverlayRenderBackend(role) {
+        if (role === 'source') {
+            return undefined;
+        }
+        switch (this.getCurrentPlanarRendering()?.renderMode) {
+            case ActorRenderMode.CPU_IMAGE:
+            case ActorRenderMode.CPU_VOLUME:
+                return RenderBackend.CPU;
+            case ActorRenderMode.VTK_IMAGE:
+            case ActorRenderMode.VTK_VOLUME_SLICE:
+                return RenderBackend.GPU;
+            default:
+                return undefined;
+        }
+    }
     applyLoadedPlanarViewState(resolvedOrientation, planarData, selectedPath) {
         const isVolumePath = selectedPath.renderMode === ActorRenderMode.CPU_VOLUME ||
             selectedPath.renderMode === ActorRenderMode.VTK_VOLUME_SLICE;

package/dist/esm/RenderingEngine/GenericViewport/Planar/PlanarViewportTypes.d.ts

@@ -1,6 +1,6 @@
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { BlendModes, InterpolationType, OrientationAxis, VOILUTFunctionType } from '../../../enums/index.js';
+import type { BlendModes, InterpolationType, OrientationAxis, RenderBackend, RenderBackendValue, VOILUTFunctionType } from '../../../enums/index.js';
 import type { ActorEntry, ActorRenderMode, ColormapPublic, IImage, IImageVolume, OrientationVectors, Point2, Point3, VOIRange } from '../../../types/index.js';
 import type { ViewportInput } from '../../../types/IViewport.js';
 import type ViewportInputOptions from '../../../types/ViewportInputOptions.js';
@@ -24,11 +24,7 @@ export interface PlanarRegisteredDataSet {
 }
 export interface PlanarSetDataOptions {
     orientation?: PlanarOrientation;
-    cpuThresholds?: {
-        image?: number;
-        volume?: number;
-    };
-    forceCPU?: boolean;
+    renderBackend?: RenderBackend | RenderBackendValue;
     role?: BindingRole;
 }
 export interface PlanarDataLoadOptions {

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathSelector.d.ts

@@ -1,4 +1,4 @@
 import type { PlanarViewState, PlanarOrientation } from './PlanarViewportTypes.js';
-export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService.js';
+export { PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, } from './PlanarRenderPathDecisionService.js';
 export type { PlanarRenderPathDecisionOptions, SelectedPlanarRenderPath, } from './PlanarRenderPathDecisionService.js';
 export declare function normalizePlanarOrientation(orientation: PlanarOrientation | undefined, acquisitionOrientation?: PlanarViewState['orientation']): PlanarViewState['orientation'];

package/dist/esm/RenderingEngine/GenericViewport/Planar/planarRenderPathSelector.js

@@ -1,6 +1,6 @@
 import { OrientationAxis } from '../../../enums/index.js';
 import { clonePlanarOrientation } from './planarLegacyCompatibility.js';
-export { DEFAULT_PLANAR_CPU_IMAGE_THRESHOLD, DEFAULT_PLANAR_CPU_VOLUME_THRESHOLD, PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, shouldUseCPU, } from './PlanarRenderPathDecisionService.js';
+export { PlanarRenderPathDecisionService, defaultPlanarRenderPathDecisionService, getPlanarAcquisitionOrientation, selectPlanarRenderPath, } from './PlanarRenderPathDecisionService.js';
 export function normalizePlanarOrientation(orientation, acquisitionOrientation) {
     if (!orientation || orientation === OrientationAxis.ACQUISITION) {
         return OrientationAxis.ACQUISITION;

package/dist/esm/RenderingEngine/TiledRenderingEngine.js

@@ -5,6 +5,7 @@ import triggerEvent from '../utilities/triggerEvent.js';
 import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline.js';
 import getOrCreateCanvas from './helpers/getOrCreateCanvas.js';
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses/index.js';
+import { attachWebGLContextEvents } from './helpers/attachWebGLContextEvents.js';
 import { getViewportClassForInput } from './helpers/viewportTypeToViewportClass.js';
 class TiledRenderingEngine extends BaseRenderingEngine {
     constructor(id) {
@@ -47,6 +48,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
                 vtkOffscreenMultiRenderWindow.newInstance();
             this.offScreenCanvasContainer = document.createElement('div');
             this.offscreenMultiRenderWindow.setContainer(this.offScreenCanvasContainer);
+            attachWebGLContextEvents(this.offscreenMultiRenderWindow, this.id);
         }
     }
     enableVTKjsDrivenViewport(viewportInputEntry) {

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

@@ -5,7 +5,7 @@ declare class WebGLContextPool {
     private viewportToContext;
     private viewportSizes;
     private contextMaxSizes;
-    constructor(count: number);
+    constructor(count: number, renderingEngineId?: string);
     getContextByIndex(index: number): {
         context: VtkOffscreenMultiRenderWindow;
         container: HTMLDivElement;

package/dist/esm/RenderingEngine/WebGLContextPool.js

@@ -1,6 +1,7 @@
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses/index.js';
+import { attachWebGLContextEvents } from './helpers/attachWebGLContextEvents.js';
 class WebGLContextPool {
-    constructor(count) {
+    constructor(count, renderingEngineId = '') {
         this.contexts = [];
         this.offScreenCanvasContainers = [];
         this.viewportToContext = new Map();
@@ -10,6 +11,7 @@ class WebGLContextPool {
             const offscreenMultiRenderWindow = vtkOffscreenMultiRenderWindow.newInstance();
             const container = document.createElement('div');
             offscreenMultiRenderWindow.setContainer(container);
+            attachWebGLContextEvents(offscreenMultiRenderWindow, renderingEngineId, i);
             this.contexts.push(offscreenMultiRenderWindow);
             this.offScreenCanvasContainers.push(container);
         }

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

@@ -0,0 +1,2 @@
+import type { VtkOffscreenMultiRenderWindow } from '../../types/index.js';
+export declare function attachWebGLContextEvents(offscreenMultiRenderWindow: VtkOffscreenMultiRenderWindow, renderingEngineId: string, contextIndex?: number): void;

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

@@ -0,0 +1,22 @@
+import eventTarget from '../../eventTarget.js';
+import { Events } from '../../enums/index.js';
+import triggerEvent from '../../utilities/triggerEvent.js';
+export function attachWebGLContextEvents(offscreenMultiRenderWindow, renderingEngineId, contextIndex = 0) {
+    const canvas = offscreenMultiRenderWindow.getOpenGLRenderWindow?.()?.getCanvas?.();
+    if (!canvas) {
+        return;
+    }
+    canvas.addEventListener('webglcontextlost', () => {
+        console.warn(`CornerstoneRender: WebGL context lost (renderingEngine=${renderingEngineId}, context=${contextIndex})`);
+        triggerEvent(eventTarget, Events.WEBGL_CONTEXT_LOST, {
+            renderingEngineId,
+            contextIndex,
+        });
+    });
+    canvas.addEventListener('webglcontextrestored', () => {
+        triggerEvent(eventTarget, Events.WEBGL_CONTEXT_RESTORED, {
+            renderingEngineId,
+            contextIndex,
+        });
+    });
+}

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

@@ -43,6 +43,11 @@ declare enum Events {
     GEOMETRY_LOADED = "GEOMETRY_LOADED",
     GEOMETRY_LOAD_PROGRESS = "GEOMETRY_LOAD_PROGRESS",
     GEOMETRY_LOADED_FAILED = "GEOMETRY_LOADED_FAILED",
-    ACTORS_CHANGED = "CORNERSTONE_ACTORS_CHANGED"
+    ACTORS_CHANGED = "CORNERSTONE_ACTORS_CHANGED",
+    RENDER_BACKEND_CHANGED = "CORNERSTONE_RENDER_BACKEND_CHANGED",
+    WEBGL_CONTEXT_LOST = "CORNERSTONE_WEBGL_CONTEXT_LOST",
+    WEBGL_CONTEXT_RESTORED = "CORNERSTONE_WEBGL_CONTEXT_RESTORED",
+    RENDER_PATH_ERROR = "CORNERSTONE_RENDER_PATH_ERROR",
+    RENDERING_PIPELINE_CHANGED = "CORNERSTONE_RENDERING_PIPELINE_CHANGED"
 }
 export default Events;

package/dist/esm/enums/Events.js

@@ -45,5 +45,10 @@ var Events;
     Events["GEOMETRY_LOAD_PROGRESS"] = "GEOMETRY_LOAD_PROGRESS";
     Events["GEOMETRY_LOADED_FAILED"] = "GEOMETRY_LOADED_FAILED";
     Events["ACTORS_CHANGED"] = "CORNERSTONE_ACTORS_CHANGED";
+    Events["RENDER_BACKEND_CHANGED"] = "CORNERSTONE_RENDER_BACKEND_CHANGED";
+    Events["WEBGL_CONTEXT_LOST"] = "CORNERSTONE_WEBGL_CONTEXT_LOST";
+    Events["WEBGL_CONTEXT_RESTORED"] = "CORNERSTONE_WEBGL_CONTEXT_RESTORED";
+    Events["RENDER_PATH_ERROR"] = "CORNERSTONE_RENDER_PATH_ERROR";
+    Events["RENDERING_PIPELINE_CHANGED"] = "CORNERSTONE_RENDERING_PIPELINE_CHANGED";
 })(Events || (Events = {}));
 export default Events;

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

@@ -0,0 +1,7 @@
+declare enum RenderBackend {
+    Auto = "auto",
+    GPU = "gpu",
+    CPU = "cpu"
+}
+export type RenderBackendValue = `${RenderBackend}`;
+export default RenderBackend;

package/dist/esm/enums/RenderBackend.js

@@ -0,0 +1,7 @@
+var RenderBackend;
+(function (RenderBackend) {
+    RenderBackend["Auto"] = "auto";
+    RenderBackend["GPU"] = "gpu";
+    RenderBackend["CPU"] = "cpu";
+})(RenderBackend || (RenderBackend = {}));
+export default RenderBackend;

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

@@ -18,4 +18,5 @@ import MetadataModules from './MetadataModules.js';
 import { GenerateImageType } from './GenerateImageType.js';
 import VoxelManagerEnum from './VoxelManagerEnum.js';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum.js';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, type ViewportTypesMap, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };
+import RenderBackend, { type RenderBackendValue } from './RenderBackend.js';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, type ViewportTypesMap, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, RenderBackend, type RenderBackendValue, };

package/dist/esm/enums/index.js

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

package/dist/esm/index.d.ts

@@ -34,7 +34,8 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager.j
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager.js';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement.js';
 import * as metaData from './metaData.js';
-import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init.js';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init.js';
+import { getRenderingCapabilities, detectRenderingCapabilities } from './utilities/renderingCapabilities.js';
 import Settings from './Settings.js';
 import * as volumeLoader from './loaders/volumeLoader.js';
 import * as imageLoader from './loaders/imageLoader.js';
@@ -111,4 +112,4 @@ declare const renderingEngineExportsV2: {
 };
 declare const LegacyVolumeViewport3D: typeof VolumeViewport3D;
 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, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -28,7 +28,8 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager.j
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager.js';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement.js';
 import * as metaData from './metaData.js';
-import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init.js';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init.js';
+import { getRenderingCapabilities, detectRenderingCapabilities, } from './utilities/renderingCapabilities.js';
 import Settings from './Settings.js';
 import * as volumeLoader from './loaders/volumeLoader.js';
 import * as imageLoader from './loaders/imageLoader.js';
@@ -77,4 +78,4 @@ const renderingEngineExportsV2 = {
     wsiProjection,
 };
 const LegacyVolumeViewport3D = VolumeViewport3D;
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.d.ts

@@ -1,7 +1,13 @@
 import type { Cornerstone3DConfig } from './types/index.js';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager.js';
+import { RenderBackend } from './enums/index.js';
+import type { RenderBackendValue } from './enums/index.js';
 declare function init(configuration?: Cornerstone3DConfig): boolean;
 declare function getCanUseNorm16Texture(): boolean;
+declare function getRenderBackend(): RenderBackend;
+declare function resolveAutoRenderBackend(): RenderBackend.GPU | RenderBackend.CPU;
+declare function getEffectiveRenderBackend(override?: RenderBackend | RenderBackendValue): RenderBackend.GPU | RenderBackend.CPU;
+declare function setRenderBackend(backend: RenderBackend | RenderBackendValue, reason?: string): void;
 declare function setUseCPURendering(status: boolean, updateViewports?: boolean): void;
 declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;
@@ -14,4 +20,4 @@ declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
 declare function getWebWorkerManager(): CentralizedWebWorkerManager;
 declare function peerImport(moduleId: string): Promise<any>;
-export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, resolveAutoRenderBackend, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/init.js

@@ -2,10 +2,11 @@ import { getRenderingEngines } from './RenderingEngine/getRenderingEngine.js';
 let csRenderInitialized = false;
 import deepMerge from './utilities/deepMerge.js';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager.js';
-import { getSupportedTextureFormats } from './utilities/textureSupport.js';
-import { RenderingEngineModeEnum } from './enums/index.js';
+import { getRenderingCapabilities } from './utilities/renderingCapabilities.js';
+import triggerEvent from './utilities/triggerEvent.js';
+import eventTarget from './eventTarget.js';
+import { Events, RenderBackend, RenderingEngineModeEnum } from './enums/index.js';
 const defaultConfig = {
-    gpuTier: { tier: 2 },
     isMobile: false,
     rendering: {
         useCPURendering: false,
@@ -15,10 +16,7 @@ const defaultConfig = {
         renderingEngineMode: RenderingEngineModeEnum.ContextPool,
         webGlContextCount: 7,
         planar: {
-            cpuThresholds: {
-                image: 64 * 1024 * 1024,
-                volume: Infinity,
-            },
+            renderBackend: RenderBackend.Auto,
             cpuVolume: {
                 useViewportSamplingForLinear: true,
                 volumeModifiedThrottleMs: 5000,
@@ -38,21 +36,9 @@ let config = {
     rendering: { ...defaultConfig.rendering },
 };
 let webWorkerManager = null;
-let canUseNorm16Texture = false;
-function _getGLContext() {
-    const canvas = document.createElement('canvas');
-    const gl = canvas.getContext('webgl2') ||
-        canvas.getContext('webgl') ||
-        canvas.getContext('experimental-webgl');
-    return gl;
-}
-function _hasActiveWebGLContext() {
-    const gl = _getGLContext();
-    return (gl instanceof WebGLRenderingContext || gl instanceof WebGL2RenderingContext);
-}
 function _hasNorm16TextureSupport() {
-    const supportedTextureFormats = getSupportedTextureFormats();
-    return supportedTextureFormats.norm16 && supportedTextureFormats.norm16Linear;
+    const capabilities = getRenderingCapabilities();
+    return capabilities.norm16 && capabilities.norm16Linear;
 }
 function isIOS() {
     if (/iPad|iPhone|iPod/.test(navigator.platform)) {
@@ -68,7 +54,6 @@ function init(configuration = config) {
     if (csRenderInitialized) {
         return csRenderInitialized;
     }
-    canUseNorm16Texture = _hasNorm16TextureSupport();
     config = deepMerge(defaultConfig, configuration);
     if (config.isMobile) {
         config.rendering.webGlContextCount = 1;
@@ -77,17 +62,20 @@ function init(configuration = config) {
         if (configuration.rendering?.preferSizeOverAccuracy) {
             config.rendering.preferSizeOverAccuracy = true;
         }
-        else {
+        else if (!_hasNorm16TextureSupport()) {
             console.log('norm16 texture not supported, you can turn on the preferSizeOverAccuracy flag to use native data type, but be aware of the inaccuracy of the rendering in high bits');
         }
     }
-    const hasWebGLContext = _hasActiveWebGLContext();
-    if (!hasWebGLContext) {
+    const capabilities = getRenderingCapabilities();
+    if (!capabilities.webgl) {
         console.log('CornerstoneRender: GPU not detected, using CPU rendering');
         config.rendering.useCPURendering = true;
     }
     else {
         console.log('CornerstoneRender: using GPU rendering');
+        if (capabilities.softwareRasterizer) {
+            console.log(`CornerstoneRender: software rasterizer detected (${capabilities.renderer}), GPU rendering may be slow`);
+        }
     }
     csRenderInitialized = true;
     if (!webWorkerManager) {
@@ -96,14 +84,54 @@ function init(configuration = config) {
     return csRenderInitialized;
 }
 function getCanUseNorm16Texture() {
-    return canUseNorm16Texture;
+    return _hasNorm16TextureSupport();
+}
+function getRenderBackend() {
+    return (config.rendering.planar?.renderBackend ??
+        RenderBackend.Auto);
+}
+function resolveAutoRenderBackend() {
+    return config.rendering.useCPURendering
+        ? RenderBackend.CPU
+        : RenderBackend.GPU;
+}
+function getEffectiveRenderBackend(override) {
+    const backend = (override ?? getRenderBackend());
+    if (backend === RenderBackend.GPU || backend === RenderBackend.CPU) {
+        return backend;
+    }
+    return resolveAutoRenderBackend();
+}
+function setRenderBackend(backend, reason) {
+    if (backend !== RenderBackend.Auto &&
+        backend !== RenderBackend.GPU &&
+        backend !== RenderBackend.CPU) {
+        throw new Error(`[setRenderBackend] Invalid render backend: ${String(backend)}`);
+    }
+    const previous = getRenderBackend();
+    if (previous === backend) {
+        return;
+    }
+    config.rendering.planar = {
+        ...config.rendering.planar,
+        renderBackend: backend,
+    };
+    _updateRenderingPipelinesForAllViewports();
+    triggerEvent(eventTarget, Events.RENDER_BACKEND_CHANGED, {
+        previous,
+        current: backend,
+        effectiveBackend: getEffectiveRenderBackend(),
+        reason,
+    });
 }
 function setUseCPURendering(status, updateViewports = true) {
+    const previousEffective = getEffectiveRenderBackend();
     config.rendering.useCPURendering = status;
     csRenderInitialized = true;
     if (updateViewports) {
         _updateRenderingPipelinesForAllViewports();
     }
+    _notifyEffectiveBackendChange(previousEffective, 'setUseCPURendering');
 }
 function setPreferSizeOverAccuracy(status) {
     config.rendering.preferSizeOverAccuracy = status;
@@ -111,14 +139,17 @@ function setPreferSizeOverAccuracy(status) {
     _updateRenderingPipelinesForAllViewports();
 }
 function canRenderFloatTextures() {
-    if (!isIOS()) {
-        return true;
+    const capabilities = getRenderingCapabilities();
+    if (capabilities.webgl2) {
+        return capabilities.floatLinear;
     }
-    return false;
+    return !isIOS();
 }
 function resetUseCPURendering() {
-    config.rendering.useCPURendering = !_hasActiveWebGLContext();
+    const previousEffective = getEffectiveRenderBackend();
+    config.rendering.useCPURendering = !getRenderingCapabilities().webgl;
     _updateRenderingPipelinesForAllViewports();
+    _notifyEffectiveBackendChange(previousEffective, 'resetUseCPURendering');
 }
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
@@ -142,10 +173,22 @@ function setConfiguration(c) {
 function _updateRenderingPipelinesForAllViewports() {
     getRenderingEngines().forEach((engine) => {
         engine.getViewports().forEach((viewport) => {
-            viewport.updateRenderingPipeline();
+            viewport.updateRenderingPipeline?.();
         });
     });
 }
+function _notifyEffectiveBackendChange(previousEffective, reason) {
+    const effectiveBackend = getEffectiveRenderBackend();
+    if (previousEffective === effectiveBackend) {
+        return;
+    }
+    triggerEvent(eventTarget, Events.RENDER_BACKEND_CHANGED, {
+        previous: previousEffective,
+        current: effectiveBackend,
+        effectiveBackend,
+        reason,
+    });
+}
 function getWebWorkerManager() {
     if (!webWorkerManager) {
         webWorkerManager = new CentralizedWebWorkerManager();
@@ -155,4 +198,4 @@ function getWebWorkerManager() {
 async function peerImport(moduleId) {
     return config.peerImport(moduleId);
 }
-export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, resolveAutoRenderBackend, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

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

@@ -1,8 +1,6 @@
 import type { RenderingEngineModeType } from '../types/index.js';
+import type { RenderBackend, RenderBackendValue } from '../enums/index.js';
 interface Cornerstone3DConfig {
-    gpuTier?: {
-        tier?: number;
-    };
     isMobile?: boolean;
     rendering?: {
         preferSizeOverAccuracy?: boolean;
@@ -12,10 +10,7 @@ interface Cornerstone3DConfig {
         renderingEngineMode?: RenderingEngineModeType;
         webGlContextCount?: number;
         planar?: {
-            cpuThresholds?: {
-                image?: number;
-                volume?: number;
-            };
+            renderBackend?: RenderBackend | RenderBackendValue;
             cpuVolume?: {
                 useViewportSamplingForLinear?: boolean;
                 volumeModifiedThrottleMs?: number;

package/dist/esm/utilities/renderingCapabilities.d.ts

@@ -0,0 +1,16 @@
+import type { TextureFormatSupport } from './textureSupport.js';
+export declare const RENDERING_CAPABILITIES_PROBE_VERSION = 1;
+export interface RenderingCapabilities extends TextureFormatSupport {
+    webgl: boolean;
+    webgl2: boolean;
+    maxTextureSize: number;
+    renderer: string;
+    softwareRasterizer: boolean;
+}
+export declare function detectRenderingCapabilities({ useCache, }?: {
+    useCache?: boolean;
+}): RenderingCapabilities;
+export declare function getRenderingCapabilities(): RenderingCapabilities;
+export declare function resetRenderingCapabilities({ clearStorage, }?: {
+    clearStorage?: boolean;
+}): void;

package/dist/esm/utilities/renderingCapabilities.js

@@ -0,0 +1,123 @@
+import { getSupportedTextureFormats } from './textureSupport.js';
+export const RENDERING_CAPABILITIES_PROBE_VERSION = 1;
+const STORAGE_KEY = 'cornerstone3D.renderingCapabilities';
+const SOFTWARE_RASTERIZER_PATTERN = /swiftshader|llvmpipe|softpipe|software|microsoft basic render/i;
+const NO_GPU_FORMATS = {
+    norm16: false,
+    norm16Linear: false,
+    float: false,
+    floatLinear: false,
+    halfFloat: false,
+    halfFloatLinear: false,
+};
+let cachedCapabilities = null;
+function getWebGLContextInfo() {
+    const info = {
+        webgl: false,
+        webgl2: false,
+        maxTextureSize: 0,
+        renderer: '',
+    };
+    if (typeof document === 'undefined') {
+        return info;
+    }
+    try {
+        const canvas = document.createElement('canvas');
+        const gl2 = canvas.getContext('webgl2');
+        const gl = gl2 ||
+            canvas.getContext('webgl') ||
+            canvas.getContext('experimental-webgl');
+        if (!gl) {
+            return info;
+        }
+        info.webgl = true;
+        info.webgl2 = !!gl2;
+        info.maxTextureSize = Number(gl.getParameter(gl.MAX_TEXTURE_SIZE)) || 0;
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        const renderer = debugInfo
+            ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
+            : gl.getParameter(gl.RENDERER);
+        info.renderer = typeof renderer === 'string' ? renderer : '';
+        const loseContext = gl.getExtension('WEBGL_lose_context');
+        if (loseContext) {
+            loseContext.loseContext();
+        }
+    }
+    catch {
+    }
+    return info;
+}
+function readCachedFormats(renderer, webgl2) {
+    try {
+        const raw = window.localStorage?.getItem(STORAGE_KEY);
+        if (!raw) {
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        if (parsed?.probeVersion !== RENDERING_CAPABILITIES_PROBE_VERSION ||
+            parsed?.renderer !== renderer ||
+            parsed?.webgl2 !== webgl2 ||
+            typeof parsed?.formats !== 'object' ||
+            parsed?.formats === null) {
+            return null;
+        }
+        return { ...NO_GPU_FORMATS, ...parsed.formats };
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedFormats(renderer, webgl2, formats) {
+    try {
+        const payload = {
+            probeVersion: RENDERING_CAPABILITIES_PROBE_VERSION,
+            renderer,
+            webgl2,
+            formats,
+        };
+        window.localStorage?.setItem(STORAGE_KEY, JSON.stringify(payload));
+    }
+    catch {
+    }
+}
+export function detectRenderingCapabilities({ useCache = true, } = {}) {
+    const contextInfo = getWebGLContextInfo();
+    if (!contextInfo.webgl) {
+        return {
+            ...contextInfo,
+            ...NO_GPU_FORMATS,
+            softwareRasterizer: false,
+        };
+    }
+    let formats = useCache
+        ? readCachedFormats(contextInfo.renderer, contextInfo.webgl2)
+        : null;
+    if (!formats) {
+        const probed = getSupportedTextureFormats();
+        if (probed) {
+            writeCachedFormats(contextInfo.renderer, contextInfo.webgl2, probed);
+        }
+        formats = probed ?? { ...NO_GPU_FORMATS };
+    }
+    return {
+        ...contextInfo,
+        ...formats,
+        softwareRasterizer: SOFTWARE_RASTERIZER_PATTERN.test(contextInfo.renderer),
+    };
+}
+export function getRenderingCapabilities() {
+    if (!cachedCapabilities) {
+        cachedCapabilities = detectRenderingCapabilities();
+    }
+    return cachedCapabilities;
+}
+export function resetRenderingCapabilities({ clearStorage = false, } = {}) {
+    cachedCapabilities = null;
+    if (clearStorage) {
+        try {
+            window.localStorage?.removeItem(STORAGE_KEY);
+        }
+        catch {
+        }
+    }
+}

package/dist/esm/utilities/textureSupport.d.ts

@@ -1,4 +1,9 @@
-export declare function getSupportedTextureFormats(): {
+export interface TextureFormatSupport {
     norm16: boolean;
     norm16Linear: boolean;
-};
+    float: boolean;
+    floatLinear: boolean;
+    halfFloat: boolean;
+    halfFloatLinear: boolean;
+}
+export declare function getSupportedTextureFormats(): TextureFormatSupport | null;

package/dist/esm/utilities/textureSupport.js

@@ -2,14 +2,14 @@ const canvasSize = 4;
 const texWidth = 5;
 const texHeight = 1;
 const pixelToCheck = [1, 1];
-function main({ ext, filterType, texData, internalFormat, glDataType }) {
+function createProbeContext() {
     try {
         const canvas = document.createElement('canvas');
         canvas.width = canvasSize;
         canvas.height = canvasSize;
         const gl = canvas.getContext('webgl2');
         if (!gl) {
-            return false;
+            return null;
         }
         const vs = `#version 300 es
     void main() {
@@ -31,31 +31,40 @@ function main({ ext, filterType, texData, internalFormat, glDataType }) {
         color = vec4(vec3(intColor.rrr), 1);
     }
     `;
-        let extToUse;
-        if (ext) {
-            extToUse = gl.getExtension(ext);
-            if (!extToUse) {
-                return false;
-            }
-        }
         const vertexShader = gl.createShader(gl.VERTEX_SHADER);
         gl.shaderSource(vertexShader, vs);
         gl.compileShader(vertexShader);
         if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
-            return false;
+            return null;
         }
         const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
         gl.shaderSource(fragmentShader, fs);
         gl.compileShader(fragmentShader);
         if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
-            return false;
+            return null;
         }
         const program = gl.createProgram();
         gl.attachShader(program, vertexShader);
         gl.attachShader(program, fragmentShader);
         gl.linkProgram(program);
         if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-            return false;
+            return null;
+        }
+        gl.useProgram(program);
+        return gl;
+    }
+    catch (e) {
+        return null;
+    }
+}
+function probeFormat(gl, { ext, filterType, texData, internalFormat, glDataType }) {
+    try {
+        let extToUse;
+        if (ext) {
+            extToUse = gl.getExtension(ext);
+            if (!extToUse) {
+                return false;
+            }
         }
         const tex = gl.createTexture();
         gl.bindTexture(gl.TEXTURE_2D, tex);
@@ -63,15 +72,13 @@ function main({ ext, filterType, texData, internalFormat, glDataType }) {
         const filter = filterType === 'LINEAR' ? gl.LINEAR : gl.NEAREST;
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-        gl.useProgram(program);
+        gl.clearColor(0, 0, 0, 0);
+        gl.clear(gl.COLOR_BUFFER_BIT);
         gl.drawArrays(gl.POINTS, 0, 1);
         const pixel = new Uint8Array(4);
         gl.readPixels(pixelToCheck[0], pixelToCheck[1], 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
         const [r, g, b] = pixel;
-        const webglLoseContext = gl.getExtension('WEBGL_lose_context');
-        if (webglLoseContext) {
-            webglLoseContext.loseContext();
-        }
+        gl.deleteTexture(tex);
         return r === g && g === b && r !== 0;
     }
     catch (e) {
@@ -79,23 +86,60 @@ function main({ ext, filterType, texData, internalFormat, glDataType }) {
     }
 }
 export function getSupportedTextureFormats() {
+    const gl = createProbeContext();
+    if (!gl) {
+        return null;
+    }
     const norm16TexData = new Int16Array([
         32767, 2000, 3000, 4000, 5000, 16784, 7000, 8000, 9000, 32767,
     ]);
-    return {
-        norm16: main({
+    const floatTexData = new Float32Array([0.3, 0.2, 0.3, 0.4, 0.5]);
+    const halfFloatTexData = new Uint16Array([13517, 12902, 13517, 13926, 14336]);
+    const result = {
+        norm16: probeFormat(gl, {
             ext: 'EXT_texture_norm16',
             filterType: 'NEAREST',
             texData: norm16TexData,
-            internalFormat: (gl, ext) => ext.R16_SNORM_EXT,
-            glDataType: (gl) => gl.SHORT,
+            internalFormat: (_gl, ext) => ext.R16_SNORM_EXT,
+            glDataType: (_gl) => _gl.SHORT,
         }),
-        norm16Linear: main({
+        norm16Linear: probeFormat(gl, {
             ext: 'EXT_texture_norm16',
             filterType: 'LINEAR',
             texData: norm16TexData,
-            internalFormat: (gl, ext) => ext.R16_SNORM_EXT,
-            glDataType: (gl) => gl.SHORT,
+            internalFormat: (_gl, ext) => ext.R16_SNORM_EXT,
+            glDataType: (_gl) => _gl.SHORT,
+        }),
+        float: probeFormat(gl, {
+            filterType: 'NEAREST',
+            texData: floatTexData,
+            internalFormat: (_gl) => _gl.R32F,
+            glDataType: (_gl) => _gl.FLOAT,
+        }),
+        floatLinear: probeFormat(gl, {
+            ext: 'OES_texture_float_linear',
+            filterType: 'LINEAR',
+            texData: floatTexData,
+            internalFormat: (_gl) => _gl.R32F,
+            glDataType: (_gl) => _gl.FLOAT,
+        }),
+        halfFloat: probeFormat(gl, {
+            filterType: 'NEAREST',
+            texData: halfFloatTexData,
+            internalFormat: (_gl) => _gl.R16F,
+            glDataType: (_gl) => _gl.HALF_FLOAT,
+        }),
+        halfFloatLinear: probeFormat(gl, {
+            filterType: 'LINEAR',
+            texData: halfFloatTexData,
+            internalFormat: (_gl) => _gl.R16F,
+            glDataType: (_gl) => _gl.HALF_FLOAT,
         }),
     };
+    const contextLost = gl.isContextLost();
+    const webglLoseContext = gl.getExtension('WEBGL_lose_context');
+    if (webglLoseContext) {
+        webglLoseContext.loseContext();
+    }
+    return contextLost ? null : result;
 }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.2.2";
+export declare const version = "5.3.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.2.2';
+export const version = '5.3.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "5.2.2",
+  "version": "5.3.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -85,18 +85,18 @@
     "prepublishOnly": "pnpm run build"
   },
   "dependencies": {
-    "@cornerstonejs/utils": "5.2.2",
+    "@cornerstonejs/utils": "5.3.0",
     "@kitware/vtk.js": "35.5.3",
     "comlink": "4.4.2",
     "gl-matrix": "3.4.3",
     "loglevel": "1.9.2"
   },
   "devDependencies": {
-    "@cornerstonejs/metadata": "5.2.2"
+    "@cornerstonejs/metadata": "5.3.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/metadata": "5.2.2",
-    "@cornerstonejs/utils": "5.2.2"
+    "@cornerstonejs/metadata": "5.3.0",
+    "@cornerstonejs/utils": "5.3.0"
   },
   "contributors": [
     {
@@ -109,5 +109,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "16455de96d51253a436e44cfec9971d7bbc1b2e4"
+  "gitHead": "6032c1e2640bcd18c7bd2bfb27181052b0e5d28e"
 }