@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

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

@@ -64,6 +64,7 @@ declare class StackViewport extends Viewport {
         resetZoom?: boolean;
         resetToCenter?: boolean;
         suppressEvents?: boolean;
+        resetAspectRatio?: boolean;
     }) => boolean;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
@@ -104,11 +105,14 @@ declare class StackViewport extends Viewport {
     private _getVOIFromCache;
     private _setPropertiesFromCache;
     private getCameraCPU;
+    private setAspectRatioForViewport;
     private setCameraCPU;
     private getPanCPU;
     private setPanCPU;
     private getZoomCPU;
     private setZoomCPU;
+    getAspectRatioCPU(): Point2;
+    setAspectRatioCPU(value: Point2, isFitViewportAfterStretch?: boolean, storeAsInitialCamera?: boolean): void;
     private setFlipCPU;
     private getRotationCPU;
     private getRotationGPU;
@@ -174,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 vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+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';
@@ -149,6 +150,7 @@ class StackViewport extends Viewport {
                 resetPan: true,
                 resetZoom: true,
                 resetToCenter: true,
+                resetAspectRatio: true,
                 suppressEvents: true,
             });
         };
@@ -395,6 +397,14 @@ class StackViewport extends Viewport {
                 cpu: this.setZoomCPU,
                 gpu: super.setZoom,
             },
+            getAspectRatio: {
+                cpu: this.getAspectRatioCPU,
+                gpu: super.getAspectRatio,
+            },
+            setAspectRatio: {
+                cpu: this.setAspectRatioCPU,
+                gpu: super.setAspectRatio,
+            },
             setVOI: {
                 cpu: this.setVOICPU,
                 gpu: this.setVOIGPU,
@@ -418,8 +428,8 @@ class StackViewport extends Viewport {
                     return true;
                 },
                 gpu: (options = {}) => {
-                    const { resetPan = true, resetZoom = true } = options;
-                    this.resetCameraGPU({ resetPan, resetZoom });
+                    const { resetPan = true, resetZoom = true, resetAspectRatio = true, } = options;
+                    this.resetCameraGPU({ resetPan, resetZoom, resetAspectRatio });
                     return true;
                 },
             },
@@ -481,9 +491,12 @@ class StackViewport extends Viewport {
         this.modality = null;
         this.useCPURendering = getShouldUseCPURendering();
         this._configureRenderingPipeline();
-        const result = this.useCPURendering
-            ? this._resetCPUFallbackElement()
-            : this._resetGPUViewport();
+        if (this.useCPURendering) {
+            this._resetCPUFallbackElement();
+        }
+        else {
+            this._resetGPUViewport();
+        }
         this.currentImageIdIndex = 0;
         this.targetImageIdIndex = 0;
         this.resetCamera();
@@ -519,21 +532,24 @@ class StackViewport extends Viewport {
                 }
             }
         }
-        const result = this.useCPURendering
-            ? this._resetCPUFallbackElement()
-            : this._resetGPUViewport();
+        if (this.useCPURendering) {
+            this._resetCPUFallbackElement();
+        }
+        else {
+            this._resetGPUViewport();
+        }
     }
     _resetCPUFallbackElement() {
         this._cpuFallbackEnabledElement = {
             canvas: this.canvas,
             renderingTools: {},
             transform: new Transform(),
-            viewport: { rotation: 0 },
+            viewport: { rotation: 0, aspectRatio: [1, 1] },
         };
     }
     _resetGPUViewport() {
         const renderer = this.getRenderer();
-        const camera = vtkCamera.newInstance();
+        const camera = extendedVtkCamera.newInstance();
         renderer.setActiveCamera(camera);
         const viewPlaneNormal = [0, 0, -1];
         this.initialViewUp = [0, -1, 0];
@@ -817,15 +833,46 @@ class StackViewport extends Viewport {
                 viewPlaneNormal[1],
                 viewPlaneNormal[2],
             ],
+            aspectRatio: viewport.aspectRatio ?? [1, 1],
             viewUp: [viewUp[0], viewUp[1], viewUp[2]],
             flipHorizontal: this.flipHorizontal,
             flipVertical: this.flipVertical,
         };
     }
+    setAspectRatioForViewport(aspectRatio, isFitViewportAfterStretch = true) {
+        const { viewport, image } = this._cpuFallbackEnabledElement;
+        if (!isFitViewportAfterStretch) {
+            viewport.aspectRatio = aspectRatio;
+            return;
+        }
+        const { clientWidth, clientHeight } = this.element;
+        const { rowPixelSpacing, columnPixelSpacing, width, height } = image;
+        const getRatioValue = ([x, y]) => x / y;
+        const oldRatioValue = getRatioValue(viewport.aspectRatio || [1, 1]);
+        const newRatioValue = getRatioValue(aspectRatio);
+        const canvasRatio = clientWidth / clientHeight;
+        const baseHeight = clientHeight * rowPixelSpacing * 0.5;
+        const calculateFitParallelScale = (rVal) => {
+            const effectiveWidth = width * columnPixelSpacing * rVal;
+            const effectiveHeight = height * rowPixelSpacing;
+            if (effectiveWidth / effectiveHeight > canvasRatio) {
+                return baseHeight / (clientWidth / effectiveWidth);
+            }
+            const fitPScale = effectiveHeight * 0.5;
+            return rVal < 1 ? fitPScale / rVal : fitPScale;
+        };
+        const ratioFactor = calculateFitParallelScale(newRatioValue) /
+            calculateFitParallelScale(oldRatioValue);
+        viewport.aspectRatio = aspectRatio;
+        if (viewport.parallelScale) {
+            viewport.parallelScale *= ratioFactor;
+            viewport.scale = baseHeight / viewport.parallelScale;
+        }
+    }
     setCameraCPU(cameraInterface) {
         const { viewport, image } = this._cpuFallbackEnabledElement;
         const previousCamera = this.getCameraCPU();
-        const { focalPoint, parallelScale, scale, flipHorizontal, flipVertical } = cameraInterface;
+        const { focalPoint, parallelScale, scale, flipHorizontal, flipVertical, aspectRatio, isFitViewportAfterStretch, } = cameraInterface;
         const { clientHeight } = this.element;
         if (focalPoint) {
             const focalPointCanvas = this.worldToCanvasCPU(focalPoint);
@@ -849,6 +896,9 @@ class StackViewport extends Viewport {
             viewport.scale = scale;
             viewport.parallelScale = (clientHeight * rowPixelSpacing * 0.5) / scale;
         }
+        if (aspectRatio) {
+            this.setAspectRatioForViewport(aspectRatio, isFitViewportAfterStretch);
+        }
         if (flipHorizontal !== undefined || flipVertical !== undefined) {
             this.setFlipCPU({ flipHorizontal, flipVertical });
         }
@@ -881,6 +931,21 @@ class StackViewport extends Viewport {
         const camera = this.getCameraCPU();
         this.setCameraCPU({ ...camera, scale: zoom });
     }
+    getAspectRatioCPU() {
+        const { aspectRatio } = this.getCameraCPU();
+        return aspectRatio ?? this.options?.aspectRatio ?? [1, 1];
+    }
+    setAspectRatioCPU(value, isFitViewportAfterStretch = true, storeAsInitialCamera = false) {
+        const camera = this.getCameraCPU();
+        if (storeAsInitialCamera) {
+            this.options.aspectRatio = value;
+        }
+        this.setCameraCPU({
+            ...camera,
+            aspectRatio: value,
+            isFitViewportAfterStretch,
+        });
+    }
     setFlipCPU({ flipHorizontal, flipVertical }) {
         const { viewport } = this._cpuFallbackEnabledElement;
         if (flipHorizontal !== undefined) {
@@ -993,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 {
@@ -1201,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 {
@@ -1348,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);
@@ -1458,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,
@@ -1509,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,
@@ -1612,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;
     }
@@ -1634,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`);
@@ -1682,14 +1728,14 @@ class StackViewport extends Viewport {
             scale,
         });
     }
-    resetCameraGPU({ resetPan, resetZoom }) {
+    resetCameraGPU(resetOptions) {
         this.setCamera({
             flipHorizontal: false,
             flipVertical: false,
             viewUp: this.initialViewUp,
         });
         const resetToCenter = true;
-        return super.resetCamera({ resetPan, resetZoom, resetToCenter });
+        return super.resetCamera({ resetToCenter, ...resetOptions });
     }
     scroll(delta, debounce = true, loop = false) {
         const imageIds = this.imageIds;
@@ -1795,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)) {
@@ -1934,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;
@@ -1951,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;