@cornerstonejs/core 4.22.11 → 4.22.12

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;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1,6 +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';
@@ -149,6 +149,7 @@ class StackViewport extends Viewport {
                 resetPan: true,
                 resetZoom: true,
                 resetToCenter: true,
+                resetAspectRatio: true,
                 suppressEvents: true,
             });
         };
@@ -395,6 +396,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 +427,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;
                 },
             },
@@ -528,12 +537,12 @@ class StackViewport extends Viewport {
             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 +826,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 +889,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 +924,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) {
@@ -1682,14 +1740,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;

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

@@ -100,6 +100,7 @@ declare class Viewport {
         resetZoom?: boolean;
         resetToCenter?: boolean;
         storeAsInitialCamera?: boolean;
+        resetAspectRatio?: boolean;
     }): boolean;
     protected setInitialCamera(camera: ICamera): void;
     protected setFitToCanvasCamera(camera: ICamera): void;
@@ -111,11 +112,14 @@ declare class Viewport {
     setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
     getZoom(compareCamera?: ICamera): number;
     setZoom(value: number, storeAsInitialCamera?: boolean): void;
+    getAspectRatio(): Point2;
+    setAspectRatio(value: Point2, isFitViewportAfterStretch?: boolean, storeAsInitialCamera?: boolean): void;
     private _getFocalPointForViewPlaneReset;
     getCanvas(): HTMLCanvasElement;
     protected getVtkActiveCamera(): vtkCamera | vtkSlabCamera;
     protected getCameraNoRotation(): ICamera;
     getCamera(): ICamera;
+    private setAspectRatioForVTKCamera;
     setCamera(cameraInterface: ICamera, storeAsInitialCamera?: boolean): void;
     triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void;
     updateCameraClippingPlanesAndRange(): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -22,6 +22,7 @@ class Viewport {
         rotation: true,
         pan: true,
         zoom: true,
+        aspectRatio: true,
         displayArea: true,
     }; }
     static { this.TransferViewPresentation = {
@@ -503,7 +504,7 @@ class Viewport {
         return this.options?.displayArea;
     }
     resetCamera(options) {
-        const { resetPan = true, resetZoom = true, resetToCenter = true, storeAsInitialCamera = true, } = options || {};
+        const { resetPan = true, resetZoom = true, resetToCenter = true, storeAsInitialCamera = true, resetAspectRatio = true, } = options || {};
         const renderer = this.getRenderer();
         this.setCameraNoEvent({
             flipHorizontal: false,
@@ -567,6 +568,9 @@ class Viewport {
         ];
         activeCamera.setPhysicalScale(radius);
         activeCamera.setPhysicalTranslation(-focalPointToSet[0], -focalPointToSet[1], -focalPointToSet[2]);
+        const targetAspectRatio = resetAspectRatio
+            ? this.options?.aspectRatio || [1, 1]
+            : this.getAspectRatio();
         this.setCamera({
             parallelScale: resetZoom ? parallelScale : previousCamera.parallelScale,
             focalPoint: focalPointToSet,
@@ -574,6 +578,8 @@ class Viewport {
             viewAngle: 90,
             viewUp: viewUpToSet,
             clippingRange: clippingRangeToUse,
+            aspectRatio: targetAspectRatio,
+            isFitViewportAfterStretch: false,
         });
         const modifiedCamera = this.getCamera();
         this.setFitToCanvasCamera(this.getCamera());
@@ -667,6 +673,21 @@ class Viewport {
             parallelScale,
         }, storeAsInitialCamera);
     }
+    getAspectRatio() {
+        const { aspectRatio } = this.getCamera();
+        return aspectRatio ?? this.options?.aspectRatio ?? [1, 1];
+    }
+    setAspectRatio(value, isFitViewportAfterStretch = true, storeAsInitialCamera = false) {
+        const camera = this.getCamera();
+        if (storeAsInitialCamera) {
+            this.options.aspectRatio = value;
+        }
+        this.setCamera({
+            ...camera,
+            aspectRatio: value,
+            isFitViewportAfterStretch,
+        }, storeAsInitialCamera);
+    }
     _getFocalPointForViewPlaneReset(imageData) {
         const { focalPoint, viewPlaneNormal: normal } = this.getCamera();
         const intersections = this._getViewImageDataIntersections(imageData, focalPoint, normal);
@@ -715,6 +736,7 @@ class Viewport {
             viewAngle: vtkCamera.getViewAngle(),
             flipHorizontal: this.flipHorizontal,
             flipVertical: this.flipVertical,
+            aspectRatio: vtkCamera.getAspectRatio(),
         };
     }
     getCamera() {
@@ -724,11 +746,56 @@ class Viewport {
             rotation: this.getRotation(),
         };
     }
+    setAspectRatioForVTKCamera(aspectRatio, isFitViewportAfterStretch = true) {
+        const vtkCamera = this.getVtkActiveCamera();
+        if (!isFitViewportAfterStretch) {
+            vtkCamera.setAspectRatio(aspectRatio);
+            return;
+        }
+        const currentAspect = vtkCamera.getAspectRatio() || [1, 1];
+        if (currentAspect[0] === aspectRatio[0] &&
+            currentAspect[1] === aspectRatio[1]) {
+            return;
+        }
+        const getRatioValue = ([x, y]) => x / y;
+        const oldRatioValue = getRatioValue(currentAspect);
+        const newRatioValue = getRatioValue(aspectRatio);
+        vtkCamera.setAspectRatio(aspectRatio);
+        const imageData = this.getDefaultImageData();
+        if (!imageData)
+            return;
+        const getFitScale = (rVal) => {
+            const { widthWorld, heightWorld } = getCubeSizeInView(imageData, vtkCamera.getViewPlaneNormal(), vtkCamera.getViewUp());
+            const canvasAspectRatio = this.sWidth / this.sHeight;
+            const effectiveWidth = widthWorld * rVal;
+            const effectiveImageRatio = effectiveWidth / heightWorld;
+            let fitScale = effectiveImageRatio > canvasAspectRatio
+                ? effectiveWidth / (2 * canvasAspectRatio)
+                : heightWorld / 2;
+            if (rVal < 1)
+                fitScale /= rVal;
+            return fitScale;
+        };
+        const ratioFactor = getFitScale(newRatioValue) / getFitScale(oldRatioValue);
+        vtkCamera.setParallelScale(vtkCamera.getParallelScale() * ratioFactor);
+        if (this.initialCamera?.parallelScale) {
+            this.initialCamera = {
+                ...this.initialCamera,
+                parallelScale: this.initialCamera.parallelScale * ratioFactor,
+            };
+        }
+        if (this.fitToCanvasCamera?.parallelScale) {
+            this.fitToCanvasCamera = {
+                ...this.fitToCanvasCamera,
+                parallelScale: this.fitToCanvasCamera.parallelScale * ratioFactor,
+            };
+        }
+    }
     setCamera(cameraInterface, storeAsInitialCamera = false) {
         const vtkCamera = this.getVtkActiveCamera();
         const previousCamera = this.getCamera();
         const updatedCamera = Object.assign({}, previousCamera, cameraInterface);
-        const { viewUp, viewPlaneNormal, position, focalPoint, parallelScale, viewAngle, flipHorizontal, flipVertical, clippingRange, } = cameraInterface;
+        const { viewUp, viewPlaneNormal, position, focalPoint, parallelScale, viewAngle, flipHorizontal, flipVertical, clippingRange, aspectRatio, isFitViewportAfterStretch, } = cameraInterface;
         if (flipHorizontal !== undefined) {
             const flipH = (flipHorizontal && !this.flipHorizontal) ||
                 (!flipHorizontal && this.flipHorizontal);
@@ -764,6 +831,9 @@ class Viewport {
         if (clippingRange !== undefined) {
             vtkCamera.setClippingRange(clippingRange);
         }
+        if (aspectRatio) {
+            this.setAspectRatioForVTKCamera(aspectRatio, isFitViewportAfterStretch);
+        }
         const prevFocalPoint = previousCamera.focalPoint;
         const prevViewUp = previousCamera.viewUp;
         if ((prevFocalPoint && focalPoint) || (prevViewUp && viewUp)) {
@@ -986,6 +1056,7 @@ class Viewport {
         displayArea: true,
         zoom: true,
         pan: true,
+        aspectRatio: true,
         flipHorizontal: true,
         flipVertical: true,
     }) {
@@ -1001,9 +1072,14 @@ class Viewport {
         if (zoom) {
             target.zoom = initZoom;
         }
+        const currentAspectRatio = this.getAspectRatio();
+        target.aspectRatio = currentAspectRatio;
         if (pan) {
-            target.pan = this.getPan();
-            vec2.scale(target.pan, target.pan, 1 / initZoom);
+            const currentPan = this.getPan();
+            const [aspectX, aspectY] = currentAspectRatio;
+            const normalizedPanX = currentPan[0] / (initZoom * aspectX);
+            const normalizedPanY = currentPan[1] / (initZoom * aspectY);
+            target.pan = [normalizedPanX, normalizedPanY];
         }
         if (flipHorizontal) {
             target.flipHorizontal = this.flipHorizontal;
@@ -1019,13 +1095,15 @@ class Viewport {
         if (!viewPres) {
             return;
         }
-        const { displayArea, zoom = this.getZoom(), pan, rotation, flipHorizontal = this.flipHorizontal, flipVertical = this.flipVertical, } = viewPres;
+        const { displayArea, zoom = this.getZoom(), pan, aspectRatio = this.getAspectRatio(), rotation, flipHorizontal = this.flipHorizontal, flipVertical = this.flipVertical, } = viewPres;
         if (displayArea !== this.getDisplayArea()) {
             this.setDisplayArea(displayArea);
         }
         this.setZoom(zoom);
+        this.setAspectRatio(aspectRatio);
         if (pan) {
-            this.setPan(vec2.scale([0, 0], pan, zoom));
+            const [aspectX, aspectY] = aspectRatio;
+            this.setPan([pan[0] * zoom * aspectX, pan[1] * zoom * aspectY]);
         }
         if (flipHorizontal !== undefined &&
             flipHorizontal !== this.flipHorizontal) {

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -276,12 +276,12 @@ class VolumeViewport extends BaseVolumeViewport {
         }
     }
     resetCamera(options) {
-        const { resetPan = true, resetZoom = true, resetRotation = true, resetToCenter = true, suppressEvents = false, resetOrientation = true, } = options || {};
+        const { resetPan = true, resetZoom = true, resetRotation = true, resetToCenter = true, suppressEvents = false, resetOrientation = true, resetAspectRatio = true, } = options || {};
         const { orientation } = this.viewportProperties;
         if (orientation && resetOrientation) {
             this.applyViewOrientation(orientation, false);
         }
-        super.resetCamera({ resetPan, resetZoom, resetToCenter });
+        super.resetCamera({ resetPan, resetZoom, resetToCenter, resetAspectRatio });
         const activeCamera = this.getVtkActiveCamera();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
@@ -473,11 +473,13 @@ class VolumeViewport extends BaseVolumeViewport {
         const resetZoom = true;
         const resetToCenter = true;
         const resetCameraRotation = true;
+        const resetAspectRatio = true;
         this.resetCamera({
             resetPan,
             resetZoom,
             resetToCenter,
             resetCameraRotation,
+            resetAspectRatio,
         });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }

package/dist/esm/RenderingEngine/helpers/cpuFallback/rendering/calculateTransform.js

@@ -1,6 +1,7 @@
 import { Transform } from './transform';
 export default function (enabledElement, scale) {
     const transform = new Transform();
+    const aspectRatio = enabledElement.viewport.aspectRatio;
     if (!enabledElement.viewport.displayedArea) {
         return transform;
     }
@@ -59,9 +60,13 @@ export default function (enabledElement, scale) {
     if (angle !== 0) {
         transform.rotate((angle * Math.PI) / 180);
     }
-    if (scale !== undefined) {
+    if (scale !== undefined && aspectRatio === undefined) {
         transform.scale(scale, scale);
     }
+    if (aspectRatio !== undefined && scale === undefined) {
+        const [scaleX, scaleY] = aspectRatio;
+        transform.scale(scaleX, scaleY);
+    }
     if (enabledElement.viewport.hflip) {
         transform.scale(-1, 1);
     }

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

@@ -0,0 +1,2 @@
+import { mat4 } from 'gl-matrix';
+export declare function getProjectionScaleMatrix(aspectRatio: Array<number>): mat4;

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

@@ -0,0 +1,10 @@
+import { mat4 } from 'gl-matrix';
+export function getProjectionScaleMatrix(aspectRatio) {
+    const [scaleX, scaleY] = aspectRatio;
+    const projectionScaleMatrix = mat4.fromScaling(mat4.create(), [
+        scaleX,
+        scaleY,
+        1.0,
+    ]);
+    return projectionScaleMatrix;
+}

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

@@ -5,4 +5,5 @@ import setVolumesForViewports from './setVolumesForViewports';
 import addVolumesToViewports from './addVolumesToViewports';
 import volumeNewImageEventDispatcher from './volumeNewImageEventDispatcher';
 import addImageSlicesToViewports from './addImageSlicesToViewports';
-export { createVolumeActor, createVolumeMapper, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, };
+import { getProjectionScaleMatrix } from './getProjectionScaleMatrix';
+export { createVolumeActor, createVolumeMapper, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, getProjectionScaleMatrix, };

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

@@ -5,4 +5,5 @@ import setVolumesForViewports from './setVolumesForViewports';
 import addVolumesToViewports from './addVolumesToViewports';
 import volumeNewImageEventDispatcher from './volumeNewImageEventDispatcher';
 import addImageSlicesToViewports from './addImageSlicesToViewports';
-export { createVolumeActor, createVolumeMapper, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, };
+import { getProjectionScaleMatrix } from './getProjectionScaleMatrix';
+export { createVolumeActor, createVolumeMapper, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, getProjectionScaleMatrix, };

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

@@ -0,0 +1,38 @@
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+interface ICameraInitialValues {
+    position?: number[];
+    focalPoint?: number[];
+    viewUp?: number[];
+    directionOfProjection?: number[];
+    parallelProjection?: boolean;
+    useHorizontalViewAngle?: boolean;
+    viewAngle?: number;
+    parallelScale?: number;
+    clippingRange?: number[];
+    windowCenter?: number[];
+    viewPlaneNormal?: number[];
+    useOffAxisProjection?: boolean;
+    screenBottomLeft?: number[];
+    screenBottomRight?: number[];
+    screenTopRight?: number[];
+    freezeFocalPoint?: boolean;
+    physicalTranslation?: number[];
+    physicalScale?: number;
+    physicalViewUp?: number[];
+    physicalViewNorth?: number[];
+    aspectRatio?: number[];
+}
+declare module '@kitware/vtk.js/Rendering/Core/Camera' {
+    interface vtkCamera {
+        getAspectRatio(): [x: number, y: number];
+        setAspectRatio(aspectRatio: [x: number, y: number]): boolean;
+    }
+}
+export type extendedVtkCamera = vtkCamera;
+export declare function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export declare const newInstance: (initialValues?: ICameraInitialValues) => extendedVtkCamera;
+declare const _default: {
+    newInstance: (initialValues?: ICameraInitialValues) => extendedVtkCamera;
+    extend: typeof extend;
+};
+export default _default;

package/dist/esm/RenderingEngine/vtkClasses/extendedVtkCamera.js

@@ -0,0 +1,35 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import { getProjectionScaleMatrix } from '../helpers/getProjectionScaleMatrix';
+import { getNormalizedAspectRatio } from '../../utilities/getNormalizedAspectRatio';
+import { mat4 } from 'gl-matrix';
+function extendedVtkCamera(publicAPI, model) {
+    model.classHierarchy.push('extendedVtkCamera');
+    const superGetProjectionMatrix = publicAPI.getProjectionMatrix;
+    publicAPI.getProjectionMatrix = (aspect, nearZ, farZ) => {
+        const matrix = superGetProjectionMatrix(aspect, nearZ, farZ);
+        const [sx, sy] = getNormalizedAspectRatio(model.aspectRatio);
+        if (sx !== 1.0 || sy !== 1.0) {
+            const scaleMatrix = getProjectionScaleMatrix([sx, sy]);
+            mat4.multiply(matrix, scaleMatrix, matrix);
+        }
+        return matrix;
+    };
+    publicAPI.getAspectRatio = () => {
+        return model.aspectRatio;
+    };
+    publicAPI.setAspectRatio = (aspectRatio) => {
+        model.aspectRatio = aspectRatio;
+    };
+}
+const DEFAULT_VALUES = {
+    aspectRatio: [1, 1],
+};
+export function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    vtkCamera.extend(publicAPI, model, initialValues);
+    macro.setGet(publicAPI, model, ['aspectRatio']);
+    extendedVtkCamera(publicAPI, model);
+}
+export const newInstance = macro.newInstance(extend, 'extendedVtkCamera');
+export default { newInstance, extend };

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

@@ -131,6 +131,8 @@ export interface vtkSlabCamera extends vtkObject {
     zoom(factor: number): void;
     setIsPerformingCoordinateTransformation(status: boolean): void;
     computeCameraLightTransform(): void;
+    getAspectRatio(): [x: number, y: number];
+    setAspectRatio(aspectRatio: [x: number, y: number]): boolean;
 }
 declare function extend(publicAPI: any, model: any, initialValues?: ICameraInitialValues): void;
 declare const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;

package/dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.js

@@ -1,13 +1,15 @@
 import macro from '@kitware/vtk.js/macros';
-import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import extendedVtkCamera from './extendedVtkCamera';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { vec3, mat4 } from 'gl-matrix';
+import { getProjectionScaleMatrix } from '../helpers/getProjectionScaleMatrix';
+import { getNormalizedAspectRatio } from '../../utilities/getNormalizedAspectRatio';
 const DEFAULT_VALUES = {
     isPerformingCoordinateTransformation: false,
 };
 function extend(publicAPI, model, initialValues = {}) {
     Object.assign(model, DEFAULT_VALUES, initialValues);
-    vtkCamera.extend(publicAPI, model, initialValues);
+    extendedVtkCamera.extend(publicAPI, model, initialValues);
     macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
     vtkSlabCamera(publicAPI, model);
 }
@@ -78,6 +80,11 @@ function vtkSlabCamera(publicAPI, model) {
             tmpMatrix[11] = (-2.0 * znear * zfar) / (zfar - znear);
             tmpMatrix[15] = 0.0;
         }
+        const [sx, sy] = getNormalizedAspectRatio(model.aspectRatio);
+        if (sx !== 1.0 || sy !== 1.0) {
+            const scaleMatrix = getProjectionScaleMatrix([sx, sy]);
+            mat4.multiply(tmpMatrix, scaleMatrix, tmpMatrix);
+        }
         mat4.copy(result, tmpMatrix);
         return result;
     };

package/dist/esm/index.d.ts

@@ -38,7 +38,7 @@ import { convertColorArrayToRgbString } from './utilities/convertColorArrayToRgb
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
-import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix } from './RenderingEngine/helpers';
 export * from './loaders/decimatedVolumeLoader';
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, 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, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, 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, getProjectionScaleMatrix, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -36,6 +36,6 @@ import { convertColorArrayToRgbString } from './utilities/convertColorArrayToRgb
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
-import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, } from './RenderingEngine/helpers';
 export * from './loaders/decimatedVolumeLoader';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, 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, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, 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, getProjectionScaleMatrix, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

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

@@ -2,6 +2,7 @@ import type CPUFallbackViewportDisplayedArea from './CPUFallbackViewportDisplaye
 import type CPUFallbackColormap from './CPUFallbackColormap';
 import type CPUFallbackLUT from './CPUFallbackLUT';
 import type VOILUTFunctionType from '../enums/VOILUTFunctionType';
+import type Point2 from './Point2';
 interface CPUFallbackViewport {
     scale?: number;
     parallelScale?: number;
@@ -25,5 +26,6 @@ interface CPUFallbackViewport {
     colormap?: CPUFallbackColormap;
     displayedArea?: CPUFallbackViewportDisplayedArea;
     modality?: string;
+    aspectRatio?: Point2;
 }
 export type { CPUFallbackViewport as default };

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

@@ -13,5 +13,13 @@ interface ICamera {
     flipHorizontal?: boolean;
     flipVertical?: boolean;
     clippingRange?: Point2;
+    aspectRatio?: Point2;
+    isFitViewportAfterStretch?: boolean;
 }
-export type { ICamera as default };
+interface ResetCameraOptions {
+    resetPan?: boolean;
+    resetZoom?: boolean;
+    resetToCenter?: boolean;
+    resetAspectRatio?: boolean;
+}
+export type { ICamera as default, ResetCameraOptions };

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

@@ -118,6 +118,7 @@ interface CPUFallbackEnabledElement {
         imagePixelModule?: ImagePixelModule;
     };
     voxelManager?: IVoxelManager<number> | IVoxelManager<RGB>;
+    aspectRatio?: Point2;
 }
 export type { IImage as default };
 export type { CPUFallbackEnabledElement };

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

@@ -51,6 +51,7 @@ export interface ViewPresentation {
     pan?: Point2;
     flipHorizontal?: boolean;
     flipVertical?: boolean;
+    aspectRatio?: Point2;
 }
 export interface ViewPresentationSelector {
     slabThickness?: number;
@@ -58,6 +59,7 @@ export interface ViewPresentationSelector {
     displayArea?: boolean;
     zoom?: boolean;
     pan?: boolean;
+    aspectRatio?: boolean;
     flipHorizontal?: boolean;
     flipVertical?: boolean;
     windowLevel?: boolean;

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

@@ -2,11 +2,13 @@ import type { OrientationAxis } from '../enums';
 import type OrientationVectors from './OrientationVectors';
 import type DisplayArea from './displayArea';
 import type RGB from './RGB';
+import type Point2 from './Point2';
 interface ViewportInputOptions {
     background?: RGB;
     orientation?: OrientationAxis | OrientationVectors;
     displayArea?: DisplayArea;
     suppressEvents?: boolean;
     parallelProjection?: boolean;
+    aspectRatio?: Point2;
 }
 export type { ViewportInputOptions as default };

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

@@ -106,6 +106,7 @@ import type JumpToSliceOptions from './JumpToSliceOptions';
 import type GeometryLoaderFn from './GeometryLoaderFn';
 import type { RenderingEngineModeType } from './RenderingEngineMode';
 import type { VtkOffscreenMultiRenderWindow } from './VtkOffscreenMultiRenderWindow';
+import type { ResetCameraOptions } from './ICamera';
 export type * from './MetadataModuleTypes';
 export type * from './InstanceTypes';
-export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, 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, };
+export type { Cornerstone3DConfig, IBaseStreamingImageVolume, ICamera, ResetCameraOptions, IStackViewport, IVideoViewport, IECGViewport, IWSIViewport, IVolumeViewport, IEnabledElement, ICache, IVolume, IViewportId, IImageVolume, ImageVolumeProps, IDynamicImageVolume, IRenderingEngine, ScalingParameters, PTScaling, IPointsManager, PolyDataPointConfiguration, Scaling, IStreamingImageVolume, IImage, IImageData, IImageCalibration, CPUIImageData, CPUImageData, EventTypes, ImageLoaderFn, VolumeLoaderFn, IRegisterImageLoader, IStreamingVolumeProperties, IViewport, ViewReference, DataSetOptions as ImageSetOptions, ViewPresentation, ViewPresentationSelector, ReferenceCompatibleOptions, ViewReferenceSpecifier, StackViewportProperties, VolumeViewportProperties, ViewportProperties, PublicViewportInput, VolumeActor, Actor, ActorEntry, ImageActor, ICanvasActor, IImageLoadObject, IVolumeLoadObject, IVolumeInput, VolumeInputCallback, IStackInput, StackInputCallback, ViewportPreset, Metadata, OrientationVectors, AABB2, AABB3, Point2, Point3, PointsXYZ, Point4, Mat3, Plane, ViewportInputOptions, VideoViewportProperties, WSIViewportProperties, VOIRange, VOI, DisplayArea, FlipDirection, ICachedImage, ICachedVolume, CPUFallbackEnabledElement, CPUFallbackViewport, CPUFallbackTransform, CPUFallbackColormapData, CPUFallbackViewportDisplayedArea, CPUFallbackColormapsData, CPUFallbackColormap, TransformMatrix2D, CPUFallbackLookupTable, CPUFallbackLUT, CPUFallbackRenderingTools, CustomEventType, ActorSliceRange, ImageSliceData, IGeometry, IGeometryLoadObject, ICachedGeometry, PublicContourSetData, ContourSetData, ContourData, IContourSet, IContour, PublicSurfaceData, SurfaceData, ISurface, PublicMeshData, MeshData, IMesh, RGB, ColormapPublic, ColormapRegistration, PixelDataTypedArray, PixelDataTypedArrayString, ImagePixelModule, ImagePlaneModule, AffineMatrix, ImageLoadListener, InternalVideoCamera, VideoViewportInput, 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, };

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

@@ -0,0 +1,2 @@
+import type { Point2 } from '../types';
+export declare const getNormalizedAspectRatio: (aspectRatio: Point2) => Point2;

package/dist/esm/utilities/getNormalizedAspectRatio.js

@@ -0,0 +1,12 @@
+import isEqual from './isEqual';
+const EPSILON = 1e10;
+export const getNormalizedAspectRatio = (aspectRatio) => {
+    const [width, height] = aspectRatio;
+    if (isEqual(width, height)) {
+        return [1, 1];
+    }
+    const min = Math.min(width, height);
+    const normalizedW = Math.round((width / min) * EPSILON) / EPSILON;
+    const normalizedH = Math.round((height / min) * EPSILON) / EPSILON;
+    return [normalizedW, normalizedH];
+};

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

@@ -97,7 +97,8 @@ export * from './getPixelSpacingInformation';
 export * from './getPlaneCubeIntersectionDimensions';
 export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
+import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, getNormalizedAspectRatio, };

package/dist/esm/utilities/index.js

@@ -98,7 +98,8 @@ export * from './getPixelSpacingInformation';
 export * from './getPlaneCubeIntersectionDimensions';
 export * from './rotateToViewCoordinates';
 import { asArray } from './asArray';
+import { getNormalizedAspectRatio } from './getNormalizedAspectRatio';
 export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 export * from './isEqual';
-export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, };
+export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, convertColorArrayToRgbString, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, handleMultiframe4D, generateFrameImageId, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, asArray, getNormalizedAspectRatio, };

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.22.11";
+export declare const version = "4.22.12";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.22.11';
+export const version = '4.22.12';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.22.11",
+  "version": "4.22.12",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "9cc703acb396d12b37fdc8af4727218574494caa"
+  "gitHead": "5cb108650fe38eac81881750b859b08de4c45cce"
 }