@cornerstonejs/core 4.22.13 → 5.0.0

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

@@ -0,0 +1,23 @@
+export { defaultRenderPathResolver, DefaultRenderPathResolver, } from './DefaultRenderPathResolver';
+export { default as GenericViewport } from './GenericViewport';
+export { ViewportProjectionService, viewportProjection, } from './viewportProjection';
+export type { BuiltInViewportProjectionByKind, BuiltInViewportProjectionByType, BuiltInViewportProjectionKind, BuiltInViewportProjectionType, ProjectionPresentationForKind, ProjectionPresentationForViewport, ProjectionPresentationForViewportType, ProjectionSnapshotForKind, ProjectionSnapshotForViewport, ProjectionSnapshotForViewportType, ProjectionViewStateForKind, ProjectionViewStateForViewport, ProjectionViewStateForViewportType, } from './viewportProjection';
+export type { ProjectionPosition, ProjectionPresentation, ProjectionRequest, ProjectionScale, ProjectionSnapshot, ProjectionSpaces, ProjectionTransforms, ProjectionWriteOptions, ViewportProjectionAdapter, } from './ViewportProjectionTypes';
+export type { CameraFrame, CameraScale, CameraScaleMode, ViewAnchor, ViewportCameraBase, } from './ViewportCameraTypes';
+export type { BaseViewportRenderContext, BasePresentationProps, DataAddOptions, DataId, DataProvider, ICanvasWorldViewport, IFrameOfReferenceViewport, IPanViewport, IZoomViewport, LoadedData, MountedRendering, RenderPathDefinition, RenderPathAttachment, RenderPathResolver, RenderPath, ViewportDataBinding, ViewportDataReference, ViewportController, ViewportId, ViewportRenderContextType, } from './ViewportArchitectureTypes';
+export { viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, } from './ViewportArchitectureTypes';
+export { default as ECGViewport } from './ECG';
+export { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './ECG';
+export type { ECGViewState, ECGDataPresentation, ECGChannelData, ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, ECGPresentationProps, ECGProperties, ECGViewportInput, ECGGenericViewportInput, } from './ECG';
+export { default as VideoViewport } from './Video';
+export { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, } from './Video';
+export type { VideoViewState, VideoDataPresentation, VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, VideoPresentationProps, VideoProperties, VideoViewportInput, VideoGenericViewportInput, } from './Video';
+export { default as PlanarViewport } from './Planar';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, } from './Planar';
+export type { PlanarViewState, PlanarDataPresentation, PlanarOrientation, PlanarPresentationProps, PlanarProperties, PlanarRenderMode, PlanarSetDataOptions, PlanarSliceBasis, PlanarViewportInput, PlanarViewportInputOptions, PlanarResolvedICamera, PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, } from './Planar';
+export { default as VolumeViewport3D } from './Volume3D';
+export { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, } from './Volume3D';
+export type { Volume3DCamera, Volume3DDataPresentation, Volume3DPresentationProps, Volume3DProperties, Volume3DRequestedRenderMode, Volume3DSetDataOptions, Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, VolumeViewport3DInput, } from './Volume3D';
+export { default as WSIViewport } from './WSI';
+export { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, } from './WSI';
+export type { WSICamera, WSIDataPresentation, WSIDataSetOptions, WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, WSIPresentationProps, WSIProperties, WSIViewState, WSIViewportInput, WSIGenericViewportInput, } from './WSI';

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

@@ -0,0 +1,14 @@
+export { defaultRenderPathResolver, DefaultRenderPathResolver, } from './DefaultRenderPathResolver';
+export { default as GenericViewport } from './GenericViewport';
+export { ViewportProjectionService, viewportProjection, } from './viewportProjection';
+export { viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, } from './ViewportArchitectureTypes';
+export { default as ECGViewport } from './ECG';
+export { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './ECG';
+export { default as VideoViewport } from './Video';
+export { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, } from './Video';
+export { default as PlanarViewport } from './Planar';
+export { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, } from './Planar';
+export { default as VolumeViewport3D } from './Volume3D';
+export { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, } from './Volume3D';
+export { default as WSIViewport } from './WSI';
+export { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, } from './WSI';

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

@@ -0,0 +1,2 @@
+import type vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+export default function setVtkCameraClippingRange(camera: vtkCamera): void;

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

@@ -0,0 +1,8 @@
+import { RENDERING_DEFAULTS } from '../../constants';
+export default function setVtkCameraClippingRange(camera) {
+    if (camera.getParallelProjection()) {
+        camera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        return;
+    }
+    camera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+}

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

@@ -0,0 +1,98 @@
+import type { ProjectionPresentation, ProjectionRequest, ProjectionSnapshot, ProjectionWriteOptions, ViewportProjectionAdapter } from './ViewportProjectionTypes';
+import { ViewportType } from '../../enums';
+import type { ViewPresentation } from '../../types';
+import type { PlanarProjectionRequest, PlanarProjectionSnapshot } from './Planar/PlanarProjectionTypes';
+import type { PlanarViewPresentation, PlanarViewState } from './Planar/PlanarViewportTypes';
+import type { Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot } from './Volume3D/Volume3DProjectionTypes';
+import type { Volume3DCamera } from './Volume3D/viewport3DTypes';
+import type { VideoProjectionRequest, VideoProjectionSnapshot } from './Video/VideoProjectionTypes';
+import type { VideoViewState } from './Video/VideoViewportTypes';
+import type { ECGProjectionRequest, ECGProjectionSnapshot } from './ECG/ECGProjectionTypes';
+import type { ECGViewState } from './ECG/ECGViewportTypes';
+import type { WSIProjectionRequest, WSIProjectionSnapshot } from './WSI/WSIProjectionTypes';
+import type { WSIViewState } from './WSI/WSIViewportTypes';
+type RegisteredProjectionAdapter = ViewportProjectionAdapter<unknown, unknown, ProjectionSnapshot<unknown, ProjectionPresentation<unknown>>>;
+export type BuiltInViewportProjectionByKind = {
+    planar: {
+        presentation: PlanarViewPresentation;
+        request: PlanarProjectionRequest;
+        snapshot: PlanarProjectionSnapshot;
+        viewState: PlanarViewState;
+        viewportType: ViewportType.PLANAR_NEXT;
+    };
+    volume3d: {
+        presentation: Volume3DProjectionPresentation;
+        request: Volume3DProjectionRequest;
+        snapshot: Volume3DProjectionSnapshot;
+        viewState: Volume3DCamera;
+        viewportType: ViewportType.VOLUME_3D_NEXT;
+    };
+    video: {
+        presentation: ViewPresentation;
+        request: VideoProjectionRequest;
+        snapshot: VideoProjectionSnapshot;
+        viewState: VideoViewState;
+        viewportType: ViewportType.VIDEO_NEXT;
+    };
+    ecg: {
+        presentation: ViewPresentation;
+        request: ECGProjectionRequest;
+        snapshot: ECGProjectionSnapshot;
+        viewState: ECGViewState;
+        viewportType: ViewportType.ECG_NEXT;
+    };
+    wsi: {
+        presentation: ViewPresentation;
+        request: WSIProjectionRequest;
+        snapshot: WSIProjectionSnapshot;
+        viewState: WSIViewState;
+        viewportType: ViewportType.WHOLE_SLIDE_NEXT;
+    };
+};
+export type BuiltInViewportProjectionKind = keyof BuiltInViewportProjectionByKind;
+export type BuiltInViewportProjectionByType = {
+    [ViewportType.PLANAR_NEXT]: BuiltInViewportProjectionByKind['planar'];
+    [ViewportType.VOLUME_3D_NEXT]: BuiltInViewportProjectionByKind['volume3d'];
+    [ViewportType.VIDEO_NEXT]: BuiltInViewportProjectionByKind['video'];
+    [ViewportType.ECG_NEXT]: BuiltInViewportProjectionByKind['ecg'];
+    [ViewportType.WHOLE_SLIDE_NEXT]: BuiltInViewportProjectionByKind['wsi'];
+};
+export type BuiltInViewportProjectionType = keyof BuiltInViewportProjectionByType;
+export type ProjectionSnapshotForKind<TKind extends BuiltInViewportProjectionKind> = BuiltInViewportProjectionByKind[TKind]['snapshot'];
+export type ProjectionPresentationForKind<TKind extends BuiltInViewportProjectionKind> = BuiltInViewportProjectionByKind[TKind]['presentation'];
+export type ProjectionViewStateForKind<TKind extends BuiltInViewportProjectionKind> = BuiltInViewportProjectionByKind[TKind]['viewState'];
+export type ProjectionSnapshotForViewportType<TViewportType extends BuiltInViewportProjectionType> = BuiltInViewportProjectionByType[TViewportType]['snapshot'];
+export type ProjectionPresentationForViewportType<TViewportType extends BuiltInViewportProjectionType> = BuiltInViewportProjectionByType[TViewportType]['presentation'];
+export type ProjectionViewStateForViewportType<TViewportType extends BuiltInViewportProjectionType> = BuiltInViewportProjectionByType[TViewportType]['viewState'];
+type BuiltInProjectionViewport = {
+    type: BuiltInViewportProjectionType;
+};
+type ProjectionForViewport<TViewport> = TViewport extends {
+    type: infer TViewportType;
+} ? TViewportType extends BuiltInViewportProjectionType ? BuiltInViewportProjectionByType[TViewportType] : never : never;
+type ProjectionRequestForKind<TKind extends BuiltInViewportProjectionKind> = Omit<BuiltInViewportProjectionByKind[TKind]['request'], 'viewport'> & {
+    kind: TKind;
+};
+type ProjectionRequestForViewport<TViewport extends BuiltInProjectionViewport> = Omit<ProjectionForViewport<TViewport>['request'], 'viewport'>;
+export type ProjectionSnapshotForViewport<TViewport extends BuiltInProjectionViewport> = ProjectionForViewport<TViewport>['snapshot'];
+export type ProjectionPresentationForViewport<TViewport extends BuiltInProjectionViewport> = ProjectionForViewport<TViewport>['presentation'];
+export type ProjectionViewStateForViewport<TViewport extends BuiltInProjectionViewport> = ProjectionForViewport<TViewport>['viewState'];
+declare class ViewportProjectionService {
+    private readonly adapters;
+    register<TViewState, TPresentation, TSnapshot extends ProjectionSnapshot<TViewState, ProjectionPresentation<unknown>>>(adapter: ViewportProjectionAdapter<TViewState, TPresentation, TSnapshot>): void;
+    unregister(adapterId: string): void;
+    getAdapter(viewport: unknown, request?: Omit<ProjectionRequest, 'viewport'>): RegisteredProjectionAdapter | undefined;
+    get<TKind extends BuiltInViewportProjectionKind>(viewport: unknown, request: ProjectionRequestForKind<TKind>): ProjectionSnapshotForKind<TKind> | undefined;
+    get<TViewport extends BuiltInProjectionViewport>(viewport: TViewport, request?: ProjectionRequestForViewport<TViewport>): ProjectionSnapshotForViewport<TViewport> | undefined;
+    get<TSnapshot extends ProjectionSnapshot = ProjectionSnapshot>(viewport: unknown, request?: Omit<ProjectionRequest, 'viewport'>): TSnapshot | undefined;
+    getPresentation<TKind extends BuiltInViewportProjectionKind>(viewport: unknown, request: ProjectionRequestForKind<TKind>): ProjectionPresentationForKind<TKind> | undefined;
+    getPresentation<TViewport extends BuiltInProjectionViewport>(viewport: TViewport, request?: ProjectionRequestForViewport<TViewport>): ProjectionPresentationForViewport<TViewport> | undefined;
+    getPresentation<TPresentation = unknown>(viewport: unknown, request?: Omit<ProjectionRequest, 'viewport'>): TPresentation | undefined;
+    withPresentation<TKind extends BuiltInViewportProjectionKind>(viewport: unknown, presentation: Partial<ProjectionPresentationForKind<TKind>>, request: ProjectionRequestForKind<TKind>, options?: ProjectionWriteOptions): ProjectionViewStateForKind<TKind> | undefined;
+    withPresentation<TViewport extends BuiltInProjectionViewport>(viewport: TViewport, presentation: Partial<ProjectionPresentationForViewport<TViewport>>, request?: ProjectionRequestForViewport<TViewport>, options?: ProjectionWriteOptions): ProjectionViewStateForViewport<TViewport> | undefined;
+    withPresentation<TViewState = unknown, TPresentation = unknown>(viewport: unknown, presentation: Partial<TPresentation>, request?: Omit<ProjectionRequest, 'viewport'>, options?: ProjectionWriteOptions): TViewState | undefined;
+    getRegisteredAdapters(): RegisteredProjectionAdapter[];
+    clear(): void;
+}
+declare const viewportProjection: ViewportProjectionService;
+export { ViewportProjectionService, viewportProjection };

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

@@ -0,0 +1,81 @@
+import { ViewportType } from '../../enums';
+import { planarProjectionAdapter } from './Planar/planarProjectionAdapter';
+import { volume3DProjectionAdapter } from './Volume3D/volume3DProjectionAdapter';
+import { videoProjectionAdapter } from './Video/videoProjectionAdapter';
+import { ecgProjectionAdapter } from './ECG/ecgProjectionAdapter';
+import { wsiProjectionAdapter } from './WSI/wsiProjectionAdapter';
+function getViewportType(request) {
+    const viewportType = request.viewportType ??
+        request.viewport?.type;
+    return viewportType === undefined ? undefined : String(viewportType);
+}
+class ViewportProjectionService {
+    constructor() {
+        this.adapters = new Map();
+    }
+    register(adapter) {
+        this.adapters.set(adapter.id, adapter);
+    }
+    unregister(adapterId) {
+        this.adapters.delete(adapterId);
+    }
+    getAdapter(viewport, request = {}) {
+        const projectionRequest = {
+            ...request,
+            viewport,
+        };
+        const viewportType = getViewportType(projectionRequest);
+        for (const adapter of this.adapters.values()) {
+            if (request.kind && adapter.id !== request.kind) {
+                continue;
+            }
+            if (viewportType &&
+                !adapter.viewportTypes.some((type) => String(type) === viewportType)) {
+                continue;
+            }
+            return adapter;
+        }
+    }
+    get(viewport, request = {}) {
+        const adapter = this.getAdapter(viewport, request);
+        return adapter?.getSnapshot({
+            ...request,
+            viewport,
+        });
+    }
+    getPresentation(viewport, request = {}) {
+        const adapter = this.getAdapter(viewport, request);
+        const snapshot = adapter?.getSnapshot({
+            ...request,
+            viewport,
+        });
+        if (!snapshot) {
+            return;
+        }
+        return adapter.getPresentation(snapshot, request.selector);
+    }
+    withPresentation(viewport, presentation, request = {}, options) {
+        const adapter = this.getAdapter(viewport, request);
+        const snapshot = adapter?.getSnapshot({
+            ...request,
+            viewport,
+        });
+        if (!snapshot) {
+            return;
+        }
+        return adapter.withPresentation(snapshot, presentation, options);
+    }
+    getRegisteredAdapters() {
+        return Array.from(this.adapters.values());
+    }
+    clear() {
+        this.adapters.clear();
+    }
+}
+const viewportProjection = new ViewportProjectionService();
+viewportProjection.register(planarProjectionAdapter);
+viewportProjection.register(volume3DProjectionAdapter);
+viewportProjection.register(videoProjectionAdapter);
+viewportProjection.register(ecgProjectionAdapter);
+viewportProjection.register(wsiProjectionAdapter);
+export { ViewportProjectionService, viewportProjection };

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

@@ -1,19 +1,17 @@
-import type { IStackViewport, IVolumeViewport, IViewport, PublicViewportInput, VtkOffscreenMultiRenderWindow } from '../types';
+import type { IViewport, PublicViewportInput, VtkOffscreenMultiRenderWindow } from '../types';
 declare class RenderingEngine {
     hasBeenDestroyed: boolean;
     offscreenMultiRenderWindow: VtkOffscreenMultiRenderWindow;
     private _implementation?;
     constructor(id?: string);
     get id(): string;
+    disableViewport(viewportId: string): void;
     enableElement(viewportInputEntry: PublicViewportInput): void;
     disableElement(viewportId: string): void;
     setViewports(publicViewportInputEntries: PublicViewportInput[]): void;
     resize(immediate?: boolean, keepCamera?: boolean): void;
-    getViewport(viewportId: string): IViewport;
+    getViewport<T = IViewport>(viewportId: string): T;
     getViewports(): IViewport[];
-    getStackViewport(viewportId: string): IStackViewport;
-    getStackViewports(): IStackViewport[];
-    getVolumeViewports(): IVolumeViewport[];
     getRenderer(viewportId: string): import("@kitware/vtk.js/Rendering/Core/Renderer").vtkRenderer;
     fillCanvasWithBackgroundColor(canvas: HTMLCanvasElement, backgroundColor: [number, number, number]): void;
     render(): void;

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -22,6 +22,9 @@ class RenderingEngine {
     get id() {
         return this._implementation.id;
     }
+    disableViewport(viewportId) {
+        return this._implementation.disableElement(viewportId);
+    }
     enableElement(viewportInputEntry) {
         return this._implementation.enableElement(viewportInputEntry);
     }
@@ -40,15 +43,6 @@ class RenderingEngine {
     getViewports() {
         return this._implementation.getViewports();
     }
-    getStackViewport(viewportId) {
-        return this._implementation.getStackViewport(viewportId);
-    }
-    getStackViewports() {
-        return this._implementation.getStackViewports();
-    }
-    getVolumeViewports() {
-        return this._implementation.getVolumeViewports();
-    }
     getRenderer(viewportId) {
         return this._implementation.getRenderer(viewportId);
     }

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

@@ -178,7 +178,6 @@ declare class StackViewport extends Viewport {
     private _getPTPreScaledRange;
     private _isCurrentImagePTPrescaled;
     private _getDefaultPTPrescaledVOIRange;
-    private _getVOIRangeFromWindowLevel;
     private _setImageIdIndex;
     private resetCameraCPU;
     private resetCameraGPU;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1,8 +1,6 @@
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 import extendedVtkCamera from './vtkClasses/extendedVtkCamera';
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
-import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
 import vtkImageMapper from '@kitware/vtk.js/Rendering/Core/ImageMapper';
 import vtkImageSlice from '@kitware/vtk.js/Rendering/Core/ImageSlice';
 import { mat4, vec2, vec3 } from 'gl-matrix';
@@ -22,9 +20,12 @@ import { isEqual } from '../utilities/isEqual';
 import invertRgbTransferFunction from '../utilities/invertRgbTransferFunction';
 import imageRetrieveMetadataProvider from '../utilities/imageRetrieveMetadataProvider';
 import imageIdToURI from '../utilities/imageIdToURI';
+import getVOIRangeFromWindowLevel from '../utilities/getVOIRangeFromWindowLevel';
 import Viewport from './Viewport';
 import drawImageSync from './helpers/cpuFallback/drawImageSync';
+import { resolveCPUFallbackColormap } from './helpers/cpuFallback/colors';
 import { getImagePlaneModule } from '../utilities/buildMetadata';
+import { createEmptyVTKImageData } from './helpers/planarImageRendering';
 import { Events, InterpolationType, MetadataModules, RequestType, VOILUTFunctionType, ViewportStatus, } from '../enums';
 import { loadAndCacheImage } from '../loaders/imageLoader';
 import imageLoadPoolManager from '../requestPool/imageLoadPoolManager';
@@ -34,7 +35,7 @@ import getDefaultViewport from './helpers/cpuFallback/rendering/getDefaultViewpo
 import pixelToCanvas from './helpers/cpuFallback/rendering/pixelToCanvas';
 import resize from './helpers/cpuFallback/rendering/resize';
 import cache from '../cache/cache';
-import { getConfiguration, getShouldUseCPURendering } from '../init';
+import { getShouldUseCPURendering } from '../init';
 import { createProgressive } from '../loaders/ProgressiveRetrieveImages';
 import correctShift from './helpers/cpuFallback/rendering/correctShift';
 import resetCamera from './helpers/cpuFallback/rendering/resetCamera';
@@ -490,9 +491,12 @@ class StackViewport extends Viewport {
         this.modality = null;
         this.useCPURendering = getShouldUseCPURendering();
         this._configureRenderingPipeline();
-        this.useCPURendering
-            ? this._resetCPUFallbackElement()
-            : this._resetGPUViewport();
+        if (this.useCPURendering) {
+            this._resetCPUFallbackElement();
+        }
+        else {
+            this._resetGPUViewport();
+        }
         this.currentImageIdIndex = 0;
         this.targetImageIdIndex = 0;
         this.resetCamera();
@@ -528,9 +532,12 @@ class StackViewport extends Viewport {
                 }
             }
         }
-        const result = this.useCPURendering
-            ? this._resetCPUFallbackElement()
-            : this._resetGPUViewport();
+        if (this.useCPURendering) {
+            this._resetCPUFallbackElement();
+        }
+        else {
+            this._resetGPUViewport();
+        }
     }
     _resetCPUFallbackElement() {
         this._cpuFallbackEnabledElement = {
@@ -1051,7 +1058,7 @@ class StackViewport extends Viewport {
                 windowCenter: wcToUse,
                 voiLUTFunction: image.voiLUTFunction,
             };
-            const { lower, upper } = windowLevelUtil.toLowHighRange(wwToUse, wcToUse, image.voiLUTFunction);
+            const { lower, upper } = getVOIRangeFromWindowLevel(wwToUse, wcToUse, image.voiLUTFunction);
             voiRange = { lower, upper };
         }
         else {
@@ -1259,19 +1266,14 @@ class StackViewport extends Viewport {
         };
     }
     createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
-        const values = new pixelArray.constructor(pixelArray.length);
-        const scalarArray = vtkDataArray.newInstance({
-            name: 'Pixels',
-            numberOfComponents: numberOfComponents,
-            values: values,
+        return createEmptyVTKImageData({
+            origin,
+            direction,
+            dimensions,
+            spacing,
+            numberOfComponents,
+            pixelArray: new pixelArray.constructor(pixelArray.length),
         });
-        const imageData = vtkImageData.newInstance();
-        imageData.setDimensions(dimensions);
-        imageData.setSpacing(spacing);
-        imageData.setDirection(direction);
-        imageData.setOrigin(origin);
-        imageData.getPointData().setScalars(scalarArray);
-        return imageData;
     }
     _createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }) {
         try {
@@ -1406,7 +1408,7 @@ class StackViewport extends Viewport {
                     let min = 65535;
                     let max = 0;
                     for (let i = 0; i < numPixels; i++) {
-                        const rescaledPixel = Math.floor((pixelData[i] - intercept) / slope);
+                        const rescaledPixel = Math.max(0, Math.min(65535, Math.floor((pixelData[i] - intercept) / slope)));
                         intPixelData[i] = rescaledPixel;
                         min = Math.min(min, rescaledPixel);
                         max = Math.max(max, rescaledPixel);
@@ -1516,7 +1518,7 @@ class StackViewport extends Viewport {
     }
     getLoaderImageOptions(imageId) {
         const imageIdIndex = this.imageIds.indexOf(imageId);
-        const { transferSyntaxUID } = metaData.get('transferSyntax', imageId) || {};
+        const { transferSyntaxUID } = metaData.get(MetadataModules.TRANSFER_SYNTAX, imageId) || {};
         const options = {
             useRGBA: false,
             transferSyntaxUID,
@@ -1567,7 +1569,7 @@ class StackViewport extends Viewport {
         const metadata = this.getImageDataMetadata(image);
         const viewport = getDefaultViewport(this.canvas, image, this.modality, this._cpuFallbackEnabledElement.viewport.colormap);
         const { windowCenter, windowWidth, voiLUTFunction } = viewport.voi;
-        this.voiRange = windowLevelUtil.toLowHighRange(windowWidth, windowCenter, voiLUTFunction);
+        this.voiRange = getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);
         this._cpuFallbackEnabledElement.image = image;
         this._cpuFallbackEnabledElement.metadata = {
             ...metadata,
@@ -1670,7 +1672,7 @@ class StackViewport extends Viewport {
             return this.voiRange;
         }
         const { windowCenter, windowWidth, voiLUTFunction } = image;
-        let voiRange = this._getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);
+        let voiRange = getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);
         voiRange = this._getPTPreScaledRange() || voiRange;
         return voiRange;
     }
@@ -1692,20 +1694,6 @@ class StackViewport extends Viewport {
     _getDefaultPTPrescaledVOIRange() {
         return { lower: 0, upper: 5 };
     }
-    _getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction = VOILUTFunctionType.LINEAR) {
-        let center, width;
-        if (typeof windowCenter === 'number' && typeof windowWidth === 'number') {
-            center = windowCenter;
-            width = windowWidth;
-        }
-        else if (Array.isArray(windowCenter) && Array.isArray(windowWidth)) {
-            center = windowCenter[0];
-            width = windowWidth[0];
-        }
-        if (center !== undefined && width !== undefined) {
-            return windowLevelUtil.toLowHighRange(width, center, voiLUTFunction);
-        }
-    }
     async _setImageIdIndex(imageIdIndex) {
         if (imageIdIndex >= this.imageIds.length) {
             throw new Error(`ImageIdIndex provided ${imageIdIndex} is invalid, the stack only has ${this.imageIds.length} elements`);
@@ -1853,7 +1841,7 @@ class StackViewport extends Viewport {
     }
     _getVOIRangeForCurrentImage() {
         const { windowCenter, windowWidth, voiLUTFunction } = this.csImage;
-        return this._getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);
+        return getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction);
     }
     _getValidVOILUTFunction(voiLUTFunction) {
         if (!Object.values(VOILUTFunctionType).includes(voiLUTFunction)) {
@@ -1992,8 +1980,13 @@ class StackViewport extends Viewport {
     }
     setColormapCPU(colormapData) {
         this.colormap = colormapData;
-        const colormap = colormapUtils.getColormap(colormapData.name);
-        this._cpuFallbackEnabledElement.viewport.colormap = colormap;
+        const colormap = resolveCPUFallbackColormap(colormapData);
+        if (colormap) {
+            this._cpuFallbackEnabledElement.viewport.colormap = colormap;
+        }
+        else {
+            delete this._cpuFallbackEnabledElement.viewport.colormap;
+        }
         this._cpuFallbackEnabledElement.renderingTools = {};
         this.fillWithBackgroundColor();
         this.cpuRenderingInvalidated = true;
@@ -2009,8 +2002,7 @@ class StackViewport extends Viewport {
         const actor = ActorEntry.actor;
         const actorProp = actor.getProperty();
         const rgbTransferFunction = actorProp.getRGBTransferFunction();
-        const colormapObj = colormapUtils.getColormap(colormap.name) ||
-            vtkColorMaps.getPresetByName(colormap.name);
+        const colormapObj = colormapUtils.resolveColormap(colormap.name);
         if (!rgbTransferFunction) {
             const cfun = vtkColorTransferFunction.newInstance();
             cfun.applyColorMap(colormapObj);

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

@@ -5,6 +5,7 @@ import type * as EventTypes from '../types/EventTypes';
 import type { InternalViewportInput, NormalizedViewportInput, IViewport } from '../types/IViewport';
 declare class TiledRenderingEngine extends BaseRenderingEngine {
     constructor(id?: string);
+    private ensureOffscreenResources;
     protected enableVTKjsDrivenViewport(viewportInputEntry: NormalizedViewportInput): void;
     protected addVtkjsDrivenViewport(viewportInputEntry: InternalViewportInput, offscreenCanvasProperties?: {
         offScreenCanvasWidth: number;

package/dist/esm/RenderingEngine/TiledRenderingEngine.js

@@ -2,19 +2,16 @@ import BaseRenderingEngine, { VIEWPORT_MIN_SIZE } from './BaseRenderingEngine';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
-import ViewportType from '../enums/ViewportType';
-import VolumeViewport from './VolumeViewport';
-import StackViewport from './StackViewport';
 import viewportTypeUsesCustomRenderingPipeline from './helpers/viewportTypeUsesCustomRenderingPipeline';
 import getOrCreateCanvas from './helpers/getOrCreateCanvas';
-import VolumeViewport3D from './VolumeViewport3D';
 import { vtkOffscreenMultiRenderWindow } from './vtkClasses';
+import { getViewportClassForInput } from './helpers/viewportTypeToViewportClass';
 class TiledRenderingEngine extends BaseRenderingEngine {
     constructor(id) {
         super(id);
         this._renderFlaggedViewports = () => {
             this._throwIfDestroyed();
-            if (!this.useCPURendering) {
+            if (this.offscreenMultiRenderWindow) {
                 this.performVtkDrawCall();
             }
             const viewports = this._getViewportsAsArray();
@@ -41,6 +38,11 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             });
         };
         if (!this.useCPURendering) {
+            this.ensureOffscreenResources();
+        }
+    }
+    ensureOffscreenResources() {
+        if (!this.offscreenMultiRenderWindow) {
             this.offscreenMultiRenderWindow =
                 vtkOffscreenMultiRenderWindow.newInstance();
             this.offScreenCanvasContainer = document.createElement('div');
@@ -48,6 +50,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         }
     }
     enableVTKjsDrivenViewport(viewportInputEntry) {
+        this.ensureOffscreenResources();
         const viewports = this._getViewportsAsArray();
         const viewportsDrivenByVtkJs = viewports.filter((vp) => viewportTypeUsesCustomRenderingPipeline(vp.type) === false);
         const canvasesDrivenByVtkJs = viewportsDrivenByVtkJs.map((vp) => vp.canvas);
@@ -63,6 +66,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         });
     }
     addVtkjsDrivenViewport(viewportInputEntry, offscreenCanvasProperties) {
+        this.ensureOffscreenResources();
         const { element, canvas, viewportId, type, defaultOptions } = viewportInputEntry;
         element.tabIndex = -1;
         const { offScreenCanvasWidth, offScreenCanvasHeight, xOffset } = offscreenCanvasProperties;
@@ -91,20 +95,12 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             sHeight,
             defaultOptions: defaultOptions || {},
         };
-        let viewport;
-        if (type === ViewportType.STACK) {
-            viewport = new StackViewport(viewportInput);
-        }
-        else if (type === ViewportType.ORTHOGRAPHIC ||
-            type === ViewportType.PERSPECTIVE) {
-            viewport = new VolumeViewport(viewportInput);
-        }
-        else if (type === ViewportType.VOLUME_3D) {
-            viewport = new VolumeViewport3D(viewportInput);
-        }
-        else {
+        const ViewportClass = getViewportClassForInput(viewportInputEntry);
+        if (!ViewportClass) {
             throw new Error(`Viewport Type ${type} is not supported`);
         }
+        const viewport = new ViewportClass(viewportInput);
+        viewport.requestedType = viewportInputEntry.requestedType ?? type;
         this._viewports.set(viewportId, viewport);
         const eventDetail = {
             element,
@@ -159,7 +155,13 @@ class TiledRenderingEngine extends BaseRenderingEngine {
             const prevCamera = vp.getCamera();
             const rotation = vp.getRotation();
             const { flipHorizontal } = prevCamera;
-            vp.resetCameraForResize();
+            const resizeResetViewport = vp;
+            if (resizeResetViewport.resetViewStateForResize) {
+                resizeResetViewport.resetViewStateForResize();
+            }
+            else {
+                resizeResetViewport.resetCameraForResize();
+            }
             const displayArea = vp.getDisplayArea();
             if (keepCamera) {
                 if (displayArea) {
@@ -188,7 +190,8 @@ class TiledRenderingEngine extends BaseRenderingEngine {
         }
         for (let i = 0; i < renderers.length; i++) {
             const { renderer, id } = renderers[i];
-            if (this._needsRender.has(id)) {
+            const viewportId = id.split('::')[0];
+            if (this._needsRender.has(viewportId)) {
                 renderer.setDraw(true);
             }
             else {
@@ -212,7 +215,7 @@ class TiledRenderingEngine extends BaseRenderingEngine {
                 viewport.customRenderViewportToCanvas();
         }
         else {
-            if (this.useCPURendering) {
+            if (!this.offscreenMultiRenderWindow) {
                 throw new Error('GPU not available, and using a viewport with no custom render pipeline.');
             }
             const { offscreenMultiRenderWindow } = this;

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

@@ -38,20 +38,12 @@ declare class VideoViewport extends Viewport {
     private addEventListeners;
     private removeEventListeners;
     private elementDisabledHandler;
-    getImageDataMetadata(image: IImage | string): {
-        bitsAllocated: number;
-        numberOfComponents: number;
-        origin: any;
-        rows: any;
-        columns: any;
-        direction: number[];
-        dimensions: any[];
-        spacing: any[];
-        hasPixelSpacing: boolean;
-        numVoxels: number;
-        imagePlaneModule: any;
-    };
+    getImageDataMetadata(image: IImage | string): import("../utilities/VideoUtilities").VideoImageMetadata;
     setDataIds(imageIds: string[], options?: ImageSetOptions): void;
+    setDataList(entries: Array<{
+        dataId: string;
+        options?: Record<string, unknown>;
+    }>): Promise<unknown>;
     setVideo(imageId: string, frameNumber?: number): Promise<unknown>;
     private setVideoURL;
     getImageIds(): string[];