@cornerstonejs/core 5.4.10 → 5.4.12

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

@@ -1,4 +1,3 @@
-import { RenderBackend } from '../../../enums/index.js';
 import type { RenderBackendValue } from '../../../enums/index.js';
 import type { PlanarViewState, PlanarEffectiveRenderMode, PlanarOrientation, PlanarRegisteredDataSet } from './PlanarViewportTypes.js';
 export interface SelectedPlanarRenderPath {
@@ -9,7 +8,7 @@ export interface SelectedPlanarRenderPath {
 export interface PlanarRenderPathDecisionOptions {
     orientation?: PlanarOrientation;
     useSliceRendering?: boolean;
-    renderBackend?: RenderBackend | RenderBackendValue;
+    renderBackend?: RenderBackendValue;
 }
 export declare class PlanarRenderPathDecisionService {
     select(dataSet: PlanarRegisteredDataSet, options?: PlanarRenderPathDecisionOptions): SelectedPlanarRenderPath;

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

@@ -1,9 +1,9 @@
 import { vec3 } from 'gl-matrix';
 import cache from '../../../cache/cache.js';
-import { OrientationAxis, RenderBackend } from '../../../enums/index.js';
+import { OrientationAxis } from '../../../enums/index.js';
 import { getEffectiveRenderBackend } from '../../../init.js';
 import * as metaData from '../../../metaData.js';
-import { ActorRenderMode } from '../../../types/index.js';
+import { getRenderModeForBackend } from '../../helpers/renderBackendRegistry.js';
 import { isValidVolume } from '../../../utilities/isValidVolume.js';
 import { getOrientationFromScanAxisNormal } from '../../helpers/getCameraVectors.js';
 export class PlanarRenderPathDecisionService {
@@ -55,14 +55,10 @@ export class PlanarRenderPathDecisionService {
         return true;
     }
     selectImageRenderMode(options) {
-        return this.resolveBackend(options) === RenderBackend.CPU
-            ? ActorRenderMode.CPU_IMAGE
-            : ActorRenderMode.VTK_IMAGE;
+        return getRenderModeForBackend(this.resolveBackend(options), 'image');
     }
     selectVolumeRenderMode(options) {
-        return this.resolveBackend(options) === RenderBackend.CPU
-            ? ActorRenderMode.CPU_VOLUME
-            : ActorRenderMode.VTK_VOLUME_SLICE;
+        return getRenderModeForBackend(this.resolveBackend(options), 'volume');
     }
     resolveBackend(options) {
         return getEffectiveRenderBackend(options.renderBackend);

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

@@ -1,3 +1,4 @@
+import { createRegisteredPlanarRenderPaths } from '../../helpers/renderBackendRegistry.js';
 import { DefaultRenderPathResolver } from '../DefaultRenderPathResolver.js';
 import { CpuImageSlicePath } from './CpuImageSliceRenderPath.js';
 import { CpuVolumeSlicePath } from './CpuVolumeSliceRenderPath.js';
@@ -9,6 +10,7 @@ export function createDefaultPlanarRenderPaths() {
         new CpuVolumeSlicePath(),
         new VtkImageMapperPath(),
         new VtkVolumeSlicePath(),
+        ...createRegisteredPlanarRenderPaths(),
     ];
 }
 export function createPlanarRenderPathResolver(paths = createDefaultPlanarRenderPaths()) {

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

@@ -1,5 +1,6 @@
-import { Events, OrientationAxis, RenderBackend, ViewportStatus, ViewportType, VOILUTFunctionType, } from '../../../enums/index.js';
+import { Events, OrientationAxis, ViewportStatus, ViewportType, VOILUTFunctionType, } from '../../../enums/index.js';
 import { ActorRenderMode } from '../../../types/index.js';
+import { getRenderBackendForRenderMode, getRenderSurfaceForRenderMode, isImageRenderMode, isVolumeRenderMode, } from '../../helpers/renderBackendRegistry.js';
 import { isImageActor } from '../../../utilities/actorCheck.js';
 import cache from '../../../cache/cache.js';
 import { deepClone } from '../../../utilities/deepClone.js';
@@ -272,17 +273,18 @@ class PlanarViewport extends GenericViewport {
     }
     getCanvas() {
         const rendering = this.getCurrentPlanarRendering();
-        if (rendering?.renderMode === ActorRenderMode.CPU_IMAGE ||
-            rendering?.renderMode === ActorRenderMode.CPU_VOLUME) {
+        if (getRenderSurfaceForRenderMode(rendering?.renderMode) === 'cpu') {
             return this.renderContext.cpu.canvas;
         }
         return this.renderContext.vtk.canvas;
     }
     async addImages(stackInputs) {
         const rendering = this.getCurrentPlanarRendering();
-        if (rendering?.renderMode !== ActorRenderMode.VTK_IMAGE &&
-            rendering?.renderMode !== ActorRenderMode.VTK_VOLUME_SLICE &&
-            rendering?.renderMode !== ActorRenderMode.CPU_IMAGE) {
+        const renderMode = rendering?.renderMode;
+        const supportsImageOverlays = isImageRenderMode(renderMode) ||
+            (isVolumeRenderMode(renderMode) &&
+                getRenderSurfaceForRenderMode(renderMode) !== 'cpu');
+        if (!supportsImageOverlays) {
             return;
         }
         for (const stackInput of stackInputs) {
@@ -338,12 +340,10 @@ class PlanarViewport extends GenericViewport {
         }
         const renderMode = binding.rendering.renderMode;
         if (renderMode === ActorRenderMode.VTK_VOLUME ||
-            renderMode === ActorRenderMode.VTK_VOLUME_SLICE ||
-            renderMode === ActorRenderMode.CPU_VOLUME) {
+            isVolumeRenderMode(renderMode)) {
             return 'volume';
         }
-        if (renderMode === ActorRenderMode.VTK_IMAGE ||
-            renderMode === ActorRenderMode.CPU_IMAGE) {
+        if (isImageRenderMode(renderMode)) {
             return 'stack';
         }
         return this.getVolumeId() ? 'volume' : 'stack';
@@ -624,8 +624,7 @@ class PlanarViewport extends GenericViewport {
         const clampedImageIdIndex = Math.min(Math.max(0, imageIdIndex), this.getMaxImageIdIndex());
         const resolvedImageId = imageIds[clampedImageIdIndex] || imageIds[imageIds.length - 1];
         const rendering = this.getCurrentPlanarRendering();
-        if (rendering?.renderMode === ActorRenderMode.CPU_VOLUME ||
-            rendering?.renderMode === ActorRenderMode.VTK_VOLUME_SLICE) {
+        if (isVolumeRenderMode(rendering?.renderMode)) {
             const sliceWorldPoint = this.getVolumeSliceWorldPointForImageIdIndex(clampedImageIdIndex);
             if (sliceWorldPoint) {
                 this.setViewState({
@@ -878,8 +877,7 @@ class PlanarViewport extends GenericViewport {
         }
     }
     setRenderModeVisibility(renderMode, cpuCanvas, vtkCanvas) {
-        const useCPUCanvas = renderMode === ActorRenderMode.CPU_IMAGE ||
-            renderMode === ActorRenderMode.CPU_VOLUME;
+        const useCPUCanvas = getRenderSurfaceForRenderMode(renderMode) === 'cpu';
         const viewportElement = this.element.querySelector('.viewport-element');
         cpuCanvas.style.display = useCPUCanvas ? '' : 'none';
         cpuCanvas.style.pointerEvents = useCPUCanvas ? 'auto' : 'none';
@@ -1042,20 +1040,10 @@ class PlanarViewport extends GenericViewport {
         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;
-        }
+        return getRenderBackendForRenderMode(this.getCurrentPlanarRendering()?.renderMode);
     }
     applyLoadedPlanarViewState(resolvedOrientation, planarData, selectedPath) {
-        const isVolumePath = selectedPath.renderMode === ActorRenderMode.CPU_VOLUME ||
-            selectedPath.renderMode === ActorRenderMode.VTK_VOLUME_SLICE;
+        const isVolumePath = isVolumeRenderMode(selectedPath.renderMode);
         const orientation = normalizePlanarOrientation(resolvedOrientation, selectedPath.acquisitionOrientation);
         const slice = isVolumePath
             ? this.createInitialVolumeSliceState(planarData, selectedPath.renderMode, orientation)
@@ -1075,7 +1063,7 @@ class PlanarViewport extends GenericViewport {
             return;
         }
         const { height, width } = this.getCurrentCanvasDimensions();
-        const createSliceBasis = renderMode === ActorRenderMode.CPU_VOLUME
+        const createSliceBasis = getRenderSurfaceForRenderMode(renderMode) === 'cpu'
             ? createPlanarCpuVolumeSliceBasis
             : createPlanarVolumeSliceBasis;
         const initialImageIdIndex = orientation === OrientationAxis.ACQUISITION

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, RenderBackend, RenderBackendValue, VOILUTFunctionType } from '../../../enums/index.js';
+import type { BlendModes, InterpolationType, OrientationAxis, 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';
@@ -11,7 +11,7 @@ import type { CameraScaleMode, ViewAnchor } from '../ViewportCameraTypes.js';
 import type DisplayArea from '../../../types/displayArea.js';
 import type { PlanarScaleInput } from './planarCameraScale.js';
 export type PlanarRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE;
-export type PlanarEffectiveRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE | ActorRenderMode.CPU_VOLUME;
+export type PlanarEffectiveRenderMode = ActorRenderMode.CPU_IMAGE | 'webgl2d' | ActorRenderMode.VTK_IMAGE | ActorRenderMode.VTK_VOLUME_SLICE | ActorRenderMode.CPU_VOLUME | (string & {});
 export type PlanarOrientation = OrientationAxis.ACQUISITION | OrientationAxis.AXIAL | OrientationAxis.CORONAL | OrientationAxis.SAGITTAL | OrientationVectors;
 export interface PlanarRegisteredDataSet {
     imageIds: string[];
@@ -24,7 +24,7 @@ export interface PlanarRegisteredDataSet {
 }
 export interface PlanarSetDataOptions {
     orientation?: PlanarOrientation;
-    renderBackend?: RenderBackend | RenderBackendValue;
+    renderBackend?: RenderBackendValue;
     role?: BindingRole;
 }
 export interface PlanarDataLoadOptions {

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

@@ -0,0 +1,38 @@
+import type { EffectiveRenderBackend, RenderBackend as RenderBackendWire, RenderBackendConstants } from '../../types/RenderBackendRegistry.js';
+import type { RenderPathDefinition } from '../GenericViewport/ViewportArchitectureTypes.js';
+export type RenderSurface = 'vtk' | 'cpu';
+export type RenderBackendDataKind = 'image' | 'volume';
+export interface RenderBackendRenderMode {
+    id: string;
+    createDefinition?: () => RenderPathDefinition;
+}
+export interface RenderBackendRenderModes {
+    image: RenderBackendRenderMode;
+    volume?: RenderBackendRenderMode;
+}
+export interface RenderBackendDefinition {
+    backend: string;
+    renderModes: RenderBackendRenderModes;
+    surface?: RenderSurface;
+}
+type RegisterRenderBackendNamedOptions<Name extends keyof RenderBackendConstants> = RenderBackendDefinition & {
+    name: Name;
+    backend: RenderBackendConstants[Name];
+};
+type RegisterRenderBackendUnnamedOptions = RenderBackendDefinition & {
+    backend: RenderBackendWire | string;
+    name?: never;
+};
+export type RegisterRenderBackendOptions = RegisterRenderBackendNamedOptions<keyof RenderBackendConstants> | RegisterRenderBackendUnnamedOptions;
+export declare function registerRenderBackend<Name extends keyof RenderBackendConstants>(options: RegisterRenderBackendNamedOptions<Name>): void;
+export declare function registerRenderBackend(options: RegisterRenderBackendUnnamedOptions): void;
+export declare function isRegisteredRenderBackend(backend: string): boolean;
+export declare function getRenderBackendDefinition(backend: string): Readonly<RenderBackendDefinition> | undefined;
+export declare function getRenderModeForBackend(backend: string, kind: RenderBackendDataKind): string;
+export declare function getRenderBackendForRenderMode(renderMode: string | undefined): EffectiveRenderBackend | undefined;
+export declare function isVolumeRenderMode(renderMode: string | undefined): boolean;
+export declare function isImageRenderMode(renderMode: string | undefined): boolean;
+export declare function getRenderSurfaceForRenderMode(renderMode: string | undefined): RenderSurface;
+export declare function createRegisteredPlanarRenderPaths(): RenderPathDefinition[];
+export declare function __resetRenderBackendRegistry(): void;
+export {};

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

@@ -0,0 +1,133 @@
+import RenderBackends, { registerRenderBackendsConstant, } from '../../enums/RenderBackends.js';
+import { ActorRenderMode } from '../../types/IActor.js';
+const backendDefinitions = new Map();
+const renderModeIndex = new Map();
+const registeredConstantNames = [];
+let hasRegisteredCoreRenderBackends = false;
+function registerCoreRenderBackends() {
+    if (hasRegisteredCoreRenderBackends) {
+        return;
+    }
+    hasRegisteredCoreRenderBackends = true;
+    registerRenderBackend({
+        backend: RenderBackends.GPU,
+        renderModes: {
+            image: { id: ActorRenderMode.VTK_IMAGE },
+            volume: { id: ActorRenderMode.VTK_VOLUME_SLICE },
+        },
+        surface: 'vtk',
+    });
+    registerRenderBackend({
+        backend: RenderBackends.CPU,
+        renderModes: {
+            image: { id: ActorRenderMode.CPU_IMAGE },
+            volume: { id: ActorRenderMode.CPU_VOLUME },
+        },
+        surface: 'cpu',
+    });
+}
+export function registerRenderBackend({ backend, name, renderModes, surface = 'vtk', }) {
+    registerCoreRenderBackends();
+    if (backend === RenderBackends.Auto) {
+        throw new Error(`Render backend id "${RenderBackends.Auto}" is reserved for the automatic backend resolution`);
+    }
+    if (backendDefinitions.has(backend)) {
+        throw new Error(`Render backend "${backend}" is already registered`);
+    }
+    if (!renderModes?.image?.id) {
+        throw new Error(`Render backend "${backend}" must declare renderModes.image`);
+    }
+    if (renderModes.volume && renderModes.volume.id === renderModes.image.id) {
+        throw new Error(`Render backend "${backend}" must use distinct render modes for image and volume`);
+    }
+    const modeEntries = [
+        [renderModes.image.id, 'image'],
+    ];
+    if (renderModes.volume) {
+        modeEntries.push([renderModes.volume.id, 'volume']);
+    }
+    for (const [renderMode] of modeEntries) {
+        const existing = renderModeIndex.get(renderMode);
+        if (existing && existing.backend !== backend) {
+            throw new Error(`Render mode "${renderMode}" is already provided by render backend "${existing.backend}"`);
+        }
+    }
+    if (name && Object.prototype.hasOwnProperty.call(RenderBackends, name)) {
+        throw new Error(`Render backend constant "${String(name)}" already exists`);
+    }
+    backendDefinitions.set(backend, {
+        backend,
+        renderModes,
+        surface,
+    });
+    for (const [renderMode, kind] of modeEntries) {
+        renderModeIndex.set(renderMode, {
+            backend: backend,
+            kind,
+            surface,
+        });
+    }
+    if (name) {
+        registerRenderBackendsConstant(name, backend);
+        registeredConstantNames.push(name);
+    }
+}
+export function isRegisteredRenderBackend(backend) {
+    registerCoreRenderBackends();
+    return backendDefinitions.has(backend);
+}
+export function getRenderBackendDefinition(backend) {
+    registerCoreRenderBackends();
+    return backendDefinitions.get(backend);
+}
+export function getRenderModeForBackend(backend, kind) {
+    const definition = getRenderBackendDefinition(backend);
+    if (!definition) {
+        throw new Error(`Unknown render backend "${backend}". Register it with registerRenderBackend() first.`);
+    }
+    const renderMode = definition.renderModes[kind];
+    if (!renderMode) {
+        throw new Error(`Render backend "${backend}" does not support ${kind}-backed rendering`);
+    }
+    return renderMode.id;
+}
+export function getRenderBackendForRenderMode(renderMode) {
+    registerCoreRenderBackends();
+    return renderMode ? renderModeIndex.get(renderMode)?.backend : undefined;
+}
+export function isVolumeRenderMode(renderMode) {
+    registerCoreRenderBackends();
+    return renderMode
+        ? renderModeIndex.get(renderMode)?.kind === 'volume'
+        : false;
+}
+export function isImageRenderMode(renderMode) {
+    registerCoreRenderBackends();
+    return renderMode ? renderModeIndex.get(renderMode)?.kind === 'image' : false;
+}
+export function getRenderSurfaceForRenderMode(renderMode) {
+    registerCoreRenderBackends();
+    return (renderMode && renderModeIndex.get(renderMode)?.surface) || 'vtk';
+}
+export function createRegisteredPlanarRenderPaths() {
+    registerCoreRenderBackends();
+    const paths = [];
+    for (const definition of backendDefinitions.values()) {
+        const { image, volume } = definition.renderModes;
+        for (const mode of [image, volume]) {
+            if (mode?.createDefinition) {
+                paths.push(mode.createDefinition());
+            }
+        }
+    }
+    return paths;
+}
+export function __resetRenderBackendRegistry() {
+    backendDefinitions.clear();
+    renderModeIndex.clear();
+    hasRegisteredCoreRenderBackends = false;
+    for (const name of registeredConstantNames) {
+        delete RenderBackends[name];
+    }
+    registeredConstantNames.length = 0;
+}

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

@@ -46,7 +46,7 @@ declare const renderingEngineExportsV2: {
     createPlanarRenderPathResolver: typeof createPlanarRenderPathResolver;
     DefaultPlanarDataProvider: typeof DefaultPlanarDataProvider;
     planarProjection: {
-        adapter: import("./GenericViewport/index.js").ViewportProjectionAdapter<import("./GenericViewport/index.js").PlanarViewState, import("../index.js").PlanarViewPresentation, import("./GenericViewport/index.js").PlanarProjectionSnapshot>;
+        adapter: import("./GenericViewport/index.js").ViewportProjectionAdapter<import("./GenericViewport/index.js").PlanarViewState, import("./index.js").PlanarViewPresentation, import("./GenericViewport/index.js").PlanarProjectionSnapshot>;
         getSnapshot: typeof import("./GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionSnapshot;
         getZoom: typeof import("./GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionZoom;
         getScale: typeof import("./GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionScale;

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

@@ -0,0 +1,6 @@
+import type { RenderBackendConstants, RenderBackend as RenderBackendWire } from '../types/RenderBackendRegistry.js';
+export type RenderBackendsMap = RenderBackendConstants;
+export type RenderBackendValue = RenderBackendWire;
+declare const RenderBackends: RenderBackendsMap;
+export declare function registerRenderBackendsConstant<Name extends keyof RenderBackendConstants>(name: Name, backend: RenderBackendConstants[Name]): void;
+export default RenderBackends;

package/dist/esm/enums/RenderBackends.js

@@ -0,0 +1,14 @@
+const builtInRenderBackends = {
+    Auto: 'auto',
+    GPU: 'gpu',
+    CPU: 'cpu',
+};
+const RenderBackends = builtInRenderBackends;
+export function registerRenderBackendsConstant(name, backend) {
+    if (Object.prototype.hasOwnProperty.call(RenderBackends, name)) {
+        throw new Error(`Render backend constant "${String(name)}" already exists`);
+    }
+    RenderBackends[name] =
+        backend;
+}
+export default RenderBackends;

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

@@ -18,5 +18,5 @@ import MetadataModules from './MetadataModules.js';
 import { GenerateImageType } from './GenerateImageType.js';
 import VoxelManagerEnum from './VoxelManagerEnum.js';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum.js';
-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, };
+import RenderBackends, { type RenderBackendValue, type RenderBackendsMap } from './RenderBackends.js';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, type ViewportTypesMap, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, RenderBackends, type RenderBackendValue, type RenderBackendsMap, };

package/dist/esm/enums/index.js

@@ -18,5 +18,5 @@ import MetadataModules from './MetadataModules.js';
 import { GenerateImageType } from './GenerateImageType.js';
 import VoxelManagerEnum from './VoxelManagerEnum.js';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum.js';
-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, };
+import RenderBackends, {} from './RenderBackends.js';
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, RenderBackends, };

package/dist/esm/index.d.ts

@@ -1,6 +1,6 @@
 import * as Enums from './enums/index.js';
 import * as CONSTANTS from './constants/index.js';
-import { Events } from './enums/index.js';
+import { Events, RenderBackends } from './enums/index.js';
 import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine } from './RenderingEngine/index.js';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor.js';
 import createVolumeMapper, { convertMapperToNotSharedMapper } from './RenderingEngine/helpers/createVolumeMapper.js';
@@ -54,8 +54,12 @@ import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerst
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader.js';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix } from './RenderingEngine/helpers/index.js';
 import { registerViewportType, isRegisteredViewportType } from './RenderingEngine/helpers/viewportTypeToViewportClass.js';
+import { registerRenderBackend, isRegisteredRenderBackend } from './RenderingEngine/helpers/renderBackendRegistry.js';
 export type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry, } from './types/ViewportTypeRegistry.js';
 export type { ViewportTypesMap } from './enums/ViewportTypes.js';
+export type { EffectiveRenderBackend, RenderBackendConstants, RenderBackendRegistry, } from './types/RenderBackendRegistry.js';
+export type { RenderBackendsMap, RenderBackendValue, } from './enums/RenderBackends.js';
+export type { RegisterRenderBackendOptions, RenderBackendDefinition, RenderBackendRenderMode, RenderBackendRenderModes, RenderSurface, } from './RenderingEngine/helpers/renderBackendRegistry.js';
 export * from './loaders/decimatedVolumeLoader.js';
 declare const renderingEngineExportsV2: {
     GenericViewport: typeof GenericViewport;
@@ -66,7 +70,7 @@ declare const renderingEngineExportsV2: {
     createECGRenderPathResolver: typeof createECGRenderPathResolver;
     DefaultECGDataProvider: typeof DefaultECGDataProvider;
     ecgProjection: {
-        adapter: import("./index.js").ViewportProjectionAdapter<import("./index.js").ECGViewState, Types.ViewPresentation, import("./index.js").ECGProjectionSnapshot>;
+        adapter: import("./RenderingEngine/index.js").ViewportProjectionAdapter<import("./RenderingEngine/index.js").ECGViewState, Types.ViewPresentation, import("./RenderingEngine/index.js").ECGProjectionSnapshot>;
         getSnapshot: typeof import("./RenderingEngine/GenericViewport/ECG/ecgProjectionSnapshot.js").getECGProjectionSnapshot;
     };
     VideoGenericViewport: typeof VideoGenericViewport;
@@ -74,7 +78,7 @@ declare const renderingEngineExportsV2: {
     createVideoRenderPathResolver: typeof createVideoRenderPathResolver;
     DefaultVideoDataProvider: typeof DefaultVideoDataProvider;
     videoProjection: {
-        adapter: import("./index.js").ViewportProjectionAdapter<import("./index.js").VideoViewState, Types.ViewPresentation, import("./index.js").VideoProjectionSnapshot>;
+        adapter: import("./RenderingEngine/index.js").ViewportProjectionAdapter<import("./RenderingEngine/index.js").VideoViewState, Types.ViewPresentation, import("./RenderingEngine/index.js").VideoProjectionSnapshot>;
         getSnapshot: typeof import("./RenderingEngine/GenericViewport/Video/videoProjectionSnapshot.js").getVideoProjectionSnapshot;
     };
     PlanarViewport: typeof PlanarViewport;
@@ -82,7 +86,7 @@ declare const renderingEngineExportsV2: {
     createPlanarRenderPathResolver: typeof createPlanarRenderPathResolver;
     DefaultPlanarDataProvider: typeof DefaultPlanarDataProvider;
     planarProjection: {
-        adapter: import("./index.js").ViewportProjectionAdapter<import("./index.js").PlanarViewState, import("./index.js").PlanarViewPresentation, import("./index.js").PlanarProjectionSnapshot>;
+        adapter: import("./RenderingEngine/index.js").ViewportProjectionAdapter<import("./RenderingEngine/index.js").PlanarViewState, import("./RenderingEngine/index.js").PlanarViewPresentation, import("./RenderingEngine/index.js").PlanarProjectionSnapshot>;
         getSnapshot: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionSnapshot;
         getZoom: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionZoom;
         getScale: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot.js").getPlanarProjectionScale;
@@ -98,7 +102,7 @@ declare const renderingEngineExportsV2: {
     createVolume3DRenderPathResolver: typeof createVolume3DRenderPathResolver;
     DefaultVolume3DDataProvider: typeof DefaultVolume3DDataProvider;
     volume3DProjection: {
-        adapter: import("./index.js").ViewportProjectionAdapter<import("./index.js").Volume3DCamera, import("./index.js").Volume3DProjectionPresentation, import("./index.js").Volume3DProjectionSnapshot>;
+        adapter: import("./RenderingEngine/index.js").ViewportProjectionAdapter<import("./RenderingEngine/index.js").Volume3DCamera, import("./RenderingEngine/index.js").Volume3DProjectionPresentation, import("./RenderingEngine/index.js").Volume3DProjectionSnapshot>;
         getSnapshot: typeof import("./RenderingEngine/GenericViewport/Volume3D/volume3DProjectionSnapshot.js").getVolume3DProjectionSnapshot;
     };
     WSIGenericViewport: typeof WSIGenericViewport;
@@ -106,10 +110,10 @@ declare const renderingEngineExportsV2: {
     createWSIRenderPathResolver: typeof createWSIRenderPathResolver;
     DefaultWSIDataProvider: typeof DefaultWSIDataProvider;
     wsiProjection: {
-        adapter: import("./index.js").ViewportProjectionAdapter<import("./index.js").WSIViewState, Types.ViewPresentation, import("./index.js").WSIProjectionSnapshot>;
+        adapter: import("./RenderingEngine/index.js").ViewportProjectionAdapter<import("./RenderingEngine/index.js").WSIViewState, Types.ViewPresentation, import("./RenderingEngine/index.js").WSIProjectionSnapshot>;
         getSnapshot: typeof import("./RenderingEngine/GenericViewport/WSI/wsiProjectionSnapshot.js").getWSIProjectionSnapshot;
     };
 };
 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, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, 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, registerRenderBackend, isRegisteredRenderBackend, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, RenderBackends, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -1,6 +1,6 @@
 import * as Enums from './enums/index.js';
 import * as CONSTANTS from './constants/index.js';
-import { Events } from './enums/index.js';
+import { Events, RenderBackends } from './enums/index.js';
 import RenderingEngine, { BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, } from './RenderingEngine/index.js';
 import createVolumeActor from './RenderingEngine/helpers/createVolumeActor.js';
 import createVolumeMapper, { convertMapperToNotSharedMapper, } from './RenderingEngine/helpers/createVolumeMapper.js';
@@ -46,6 +46,7 @@ import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerst
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader.js';
 import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, } from './RenderingEngine/helpers/index.js';
 import { registerViewportType, isRegisteredViewportType, } from './RenderingEngine/helpers/viewportTypeToViewportClass.js';
+import { registerRenderBackend, isRegisteredRenderBackend, } from './RenderingEngine/helpers/renderBackendRegistry.js';
 export * from './loaders/decimatedVolumeLoader.js';
 const renderingEngineExportsV2 = {
     GenericViewport,
@@ -78,4 +79,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, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, 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, registerRenderBackend, isRegisteredRenderBackend, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, RenderBackends, getRenderBackend, setRenderBackend, getEffectiveRenderBackend, getRenderingCapabilities, detectRenderingCapabilities, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.d.ts

@@ -1,13 +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';
+import type { EffectiveRenderBackend } from './types/RenderBackendRegistry.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 getRenderBackend(): RenderBackendValue;
+declare function resolveAutoRenderBackend(): EffectiveRenderBackend;
+declare function getEffectiveRenderBackend(override?: RenderBackendValue): EffectiveRenderBackend;
+declare function setRenderBackend(backend: RenderBackendValue, reason?: string): void;
 declare function setUseCPURendering(status: boolean, updateViewports?: boolean): void;
 declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;

package/dist/esm/init.js

@@ -5,7 +5,8 @@ import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager.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';
+import { Events, RenderBackends, RenderingEngineModeEnum } from './enums/index.js';
+import { isRegisteredRenderBackend } from './RenderingEngine/helpers/renderBackendRegistry.js';
 const defaultConfig = {
     isMobile: false,
     rendering: {
@@ -16,7 +17,7 @@ const defaultConfig = {
         renderingEngineMode: RenderingEngineModeEnum.ContextPool,
         webGlContextCount: 7,
         planar: {
-            renderBackend: RenderBackend.Auto,
+            renderBackend: RenderBackends.Auto,
             cpuVolume: {
                 useViewportSamplingForLinear: true,
                 volumeModifiedThrottleMs: 5000,
@@ -87,26 +88,32 @@ function getCanUseNorm16Texture() {
     return _hasNorm16TextureSupport();
 }
 function getRenderBackend() {
-    return (config.rendering.planar?.renderBackend ??
-        RenderBackend.Auto);
+    return config.rendering.planar?.renderBackend ?? RenderBackends.Auto;
 }
 function resolveAutoRenderBackend() {
     return config.rendering.useCPURendering
-        ? RenderBackend.CPU
-        : RenderBackend.GPU;
+        ? RenderBackends.CPU
+        : RenderBackends.GPU;
 }
+const warnedUnregisteredBackends = new Set();
 function getEffectiveRenderBackend(override) {
-    const backend = (override ?? getRenderBackend());
-    if (backend === RenderBackend.GPU || backend === RenderBackend.CPU) {
-        return backend;
+    const backend = override ?? getRenderBackend();
+    if (backend !== RenderBackends.Auto) {
+        if (isRegisteredRenderBackend(backend)) {
+            return backend;
+        }
+        if (!warnedUnregisteredBackends.has(backend)) {
+            warnedUnregisteredBackends.add(backend);
+            console.warn(`[getEffectiveRenderBackend] Unregistered render backend "${backend}"; ` +
+                `falling back to 'auto'. Register custom backends with registerRenderBackend().`);
+        }
     }
     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)}`);
+    if (backend !== RenderBackends.Auto && !isRegisteredRenderBackend(backend)) {
+        throw new Error(`[setRenderBackend] Invalid render backend: ${String(backend)}. ` +
+            `Register custom backends with registerRenderBackend() before selecting them.`);
     }
     const previous = getRenderBackend();
     if (previous === backend) {

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

@@ -1,5 +1,5 @@
 import type { RenderingEngineModeType } from '../types/index.js';
-import type { RenderBackend, RenderBackendValue } from '../enums/index.js';
+import type { RenderBackendValue } from '../enums/index.js';
 interface Cornerstone3DConfig {
     isMobile?: boolean;
     rendering?: {
@@ -10,7 +10,7 @@ interface Cornerstone3DConfig {
         renderingEngineMode?: RenderingEngineModeType;
         webGlContextCount?: number;
         planar?: {
-            renderBackend?: RenderBackend | RenderBackendValue;
+            renderBackend?: RenderBackendValue;
             cpuVolume?: {
                 useViewportSamplingForLinear?: boolean;
                 volumeModifiedThrottleMs?: number;

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

@@ -0,0 +1,16 @@
+export interface CoreRenderBackendRegistry {
+    auto: 'auto';
+    gpu: 'gpu';
+    cpu: 'cpu';
+}
+export interface CoreRenderBackendConstants {
+    readonly Auto: 'auto';
+    readonly GPU: 'gpu';
+    readonly CPU: 'cpu';
+}
+export interface RenderBackendRegistry extends CoreRenderBackendRegistry {
+}
+export interface RenderBackendConstants extends CoreRenderBackendConstants {
+}
+export type RenderBackend = RenderBackendRegistry[keyof RenderBackendRegistry];
+export type EffectiveRenderBackend = Exclude<RenderBackend, 'auto'>;

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

@@ -113,7 +113,8 @@ import type { VtkOffscreenMultiRenderWindow } from './VtkOffscreenMultiRenderWin
 import type { ViewportDataReference } from '../RenderingEngine/GenericViewport/index.js';
 import type { ResetCameraOptions } from './ICamera.js';
 import type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry } from './ViewportTypeRegistry.js';
+import type { EffectiveRenderBackend, RenderBackendConstants, RenderBackendRegistry } from './RenderBackendRegistry.js';
 export type * from './MetadataModuleTypes.js';
 export type * from './InstanceTypes.js';
-export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, ScalingDescriptor, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, IGenericViewport, ViewportContentMode, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, RenderingEngineResizeOptions, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ActorMapperProxy, 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, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, ViewportDataReference, ViewportType, ViewportTypeRegistry, ViewportTypeConstants, };
+export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, ScalingDescriptor, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, IGenericViewport, ViewportContentMode, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, RenderingEngineResizeOptions, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ActorMapperProxy, 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, InternalECGCamera, ECGViewportInput, ECGChannel, ECGWaveformData, ECGViewportProperties, BoundsIJK, BoundsLPS, Color, ColorLUT, VolumeProps, IImageFrame, LocalVolumeOptions, IVoxelManager, IRLEVoxelMap, RLERun, ViewportInput, ImageLoadRequests, IBaseVolumeViewport, GeometryLoaderFn, ScrollOptions, JumpToSliceOptions, Memo, HistoryMemo, VoxelManager, RLEVoxelMap, RenderingEngineModeType, VtkOffscreenMultiRenderWindow, ViewportDataReference, ViewportType, ViewportTypeRegistry, ViewportTypeConstants, EffectiveRenderBackend, RenderBackendRegistry, RenderBackendConstants, };
 export { ActorRenderMode };

package/dist/esm/utilities/getVolumeViewportScrollInfo.js

@@ -2,10 +2,13 @@ import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo.js';
 function getVolumeViewportScrollInfo(viewport, volumeId, useSlabThickness = false) {
     const { sliceRange, spacingInNormalDirection, camera } = getVolumeSliceRangeInfo(viewport, volumeId, useSlabThickness);
     const { min, max, current } = sliceRange;
-    const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
-    const fraction = (current - min) / (max - min);
+    const range = max - min;
+    const numScrollSteps = range === 0 ? 0 : Math.round(range / spacingInNormalDirection);
+    const fraction = range === 0 ? 0 : (current - min) / range;
     const floatingStepNumber = fraction * numScrollSteps;
-    const currentStepIndex = Math.round(floatingStepNumber);
+    const currentStepIndex = Number.isFinite(floatingStepNumber)
+        ? Math.round(floatingStepNumber)
+        : 0;
     return {
         numScrollSteps,
         currentStepIndex,

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.4.10";
+export declare const version = "5.4.12";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.4.10';
+export const version = '5.4.12';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "5.4.10",
+  "version": "5.4.12",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -79,24 +79,24 @@
     "clean:deep": "pnpm run clean && shx rm -rf node_modules",
     "build": "pnpm run build:esm",
     "build:all": "pnpm run build:esm",
-    "dev": "tsc --project ./tsconfig.json --watch",
+    "dev": "tsc --project ./tsconfig.json --watch --sourceMap --inlineSources",
     "api-check": "api-extractor --debug run ",
     "lint": "oxlint .",
     "prepublishOnly": "pnpm run build"
   },
   "dependencies": {
-    "@cornerstonejs/utils": "5.4.10",
+    "@cornerstonejs/utils": "5.4.12",
     "@kitware/vtk.js": "35.5.3",
     "comlink": "4.4.2",
     "gl-matrix": "3.4.3",
     "loglevel": "1.9.2"
   },
   "devDependencies": {
-    "@cornerstonejs/metadata": "5.4.10"
+    "@cornerstonejs/metadata": "5.4.12"
   },
   "peerDependencies": {
-    "@cornerstonejs/metadata": "5.4.10",
-    "@cornerstonejs/utils": "5.4.10"
+    "@cornerstonejs/metadata": "5.4.12",
+    "@cornerstonejs/utils": "5.4.12"
   },
   "contributors": [
     {
@@ -109,5 +109,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "523becb5856f2b6bb5f58c08eb2b5c66bd0b17e1"
+  "gitHead": "0b67d01ebc033cc338c3612c1237b5d94025cac2"
 }

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

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

package/dist/esm/enums/RenderBackend.js

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