@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/esm/RenderingEngine/Viewport.js

@@ -1,21 +1,62 @@
 import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import { vec2, vec3 } from 'gl-matrix';
-import _cloneDeep from 'lodash.clonedeep';
 import Events from '../enums/Events';
 import ViewportStatus from '../enums/ViewportStatus';
+import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
-import { triggerEvent, planar, isImageActor, actorIsA } from '../utilities';
+import { triggerEvent, planar, isImageActor, actorIsA, isEqual, } from '../utilities';
 import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
 import { getConfiguration } from '../init';
+import { InterpolationType } from '../enums';
 class Viewport {
+    static { this.CameraViewPresentation = {
+        rotation: true,
+        pan: true,
+        zoom: true,
+        displayArea: true,
+    }; }
+    static { this.TransferViewPresentation = {
+        windowLevel: true,
+        paletteLut: true,
+    }; }
     constructor(props) {
+        this.insetImageMultiplier = 1.1;
         this.flipHorizontal = false;
         this.flipVertical = false;
         this.viewportStatus = ViewportStatus.NO_DATA;
         this._suppressCameraModifiedEvents = false;
         this.hasPixelSpacing = true;
+        this.getProperties = () => ({});
+        this.setRotation = (_rotation) => {
+        };
+        this.viewportWidgets = new Map();
+        this.addWidget = (widgetId, widget) => {
+            this.viewportWidgets.set(widgetId, widget);
+        };
+        this.getWidget = (id) => {
+            return this.viewportWidgets.get(id);
+        };
+        this.getWidgets = () => {
+            return Array.from(this.viewportWidgets.values());
+        };
+        this.removeWidgets = () => {
+            const widgets = this.getWidgets();
+            widgets.forEach((widget) => {
+                if (widget.getEnabled()) {
+                    widget.setEnabled(false);
+                }
+                if (widget.getActor && widget.getRenderer) {
+                    const actor = widget.getActor();
+                    const renderer = widget.getRenderer();
+                    if (renderer && actor) {
+                        renderer.removeActor(actor);
+                    }
+                }
+            });
+        };
         this.id = props.id;
         this.renderingEngineId = props.renderingEngineId;
         this.type = props.type;
@@ -28,11 +69,11 @@ class Viewport {
         this._actors = new Map();
         this.element.setAttribute('data-viewport-uid', this.id);
         this.element.setAttribute('data-rendering-engine-uid', this.renderingEngineId);
-        this.defaultOptions = _cloneDeep(props.defaultOptions);
+        this.defaultOptions = structuredClone(props.defaultOptions);
         this.suppressEvents = props.defaultOptions.suppressEvents
             ? props.defaultOptions.suppressEvents
             : false;
-        this.options = _cloneDeep(props.defaultOptions);
+        this.options = structuredClone(props.defaultOptions);
         this.isDisabled = false;
     }
     static get useCustomRenderingPipeline() {
@@ -60,7 +101,7 @@ class Viewport {
         renderingEngine.renderViewport(this.id);
     }
     setOptions(options, immediate = false) {
-        this.options = _cloneDeep(options);
+        this.options = structuredClone(options);
         if (this.options?.displayArea) {
             this.setDisplayArea(this.options?.displayArea);
         }
@@ -69,7 +110,7 @@ class Viewport {
         }
     }
     reset(immediate = false) {
-        this.options = _cloneDeep(this.defaultOptions);
+        this.options = structuredClone(this.defaultOptions);
         if (immediate) {
             this.render();
         }
@@ -136,6 +177,9 @@ class Viewport {
     getActors() {
         return Array.from(this._actors.values());
     }
+    getActorUIDs() {
+        return Array.from(this._actors.keys());
+    }
     getActor(actorUID) {
         return this._actors.get(actorUID);
     }
@@ -175,7 +219,10 @@ class Viewport {
             return;
         }
         actors.forEach((actor) => this.addActor(actor));
-        this.resetCamera(resetCameraPanAndZoom, resetCameraPanAndZoom);
+        this.resetCamera({
+            resetPan: resetCameraPanAndZoom,
+            resetZoom: resetCameraPanAndZoom,
+        });
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -192,11 +239,12 @@ class Viewport {
             return;
         }
         const renderer = this.getRenderer();
-        renderer.addActor(actor);
+        renderer?.addActor(actor);
         this._actors.set(actorUID, Object.assign({}, actorEntry));
+        this.updateCameraClippingPlanesAndRange();
     }
     removeAllActors() {
-        this.getRenderer().removeAllViewProps();
+        this.getRenderer()?.removeAllViewProps();
         this._actors = new Map();
         return;
     }
@@ -230,62 +278,130 @@ class Viewport {
         }
         return intersections;
     }
+    setInterpolationType(_interpolationType, _arg) {
+    }
     setDisplayArea(displayArea, suppressEvents = false) {
-        const { storeAsInitialCamera } = displayArea;
-        this.setCamera(this.fitToCanvasCamera, false);
-        const { imageArea, imageCanvasPoint } = displayArea;
-        if (imageArea) {
-            const [areaX, areaY] = imageArea;
-            const zoom = Math.min(this.getZoom() / areaX, this.getZoom() / areaY);
-            this.setZoom(zoom, storeAsInitialCamera);
-        }
-        const imageData = this.getDefaultImageData();
-        if (imageCanvasPoint && imageData) {
-            const { imagePoint, canvasPoint } = imageCanvasPoint;
-            const [canvasX, canvasY] = canvasPoint;
-            const devicePixelRatio = window?.devicePixelRatio || 1;
-            const validateCanvasPanX = this.sWidth / devicePixelRatio;
-            const validateCanvasPanY = this.sHeight / devicePixelRatio;
-            const canvasPanX = validateCanvasPanX * (canvasX - 0.5);
-            const canvasPanY = validateCanvasPanY * (canvasY - 0.5);
-            const dimensions = imageData.getDimensions();
-            const canvasZero = this.worldToCanvas([0, 0, 0]);
-            const canvasEdge = this.worldToCanvas(dimensions);
-            const canvasImage = [
-                canvasEdge[0] - canvasZero[0],
-                canvasEdge[1] - canvasZero[1],
-            ];
-            const [imgWidth, imgHeight] = canvasImage;
-            const [imageX, imageY] = imagePoint;
-            const imagePanX = imgWidth * (0.5 - imageX);
-            const imagePanY = imgHeight * (0.5 - imageY);
-            const newPositionX = imagePanX + canvasPanX;
-            const newPositionY = imagePanY + canvasPanY;
-            const deltaPoint2 = [newPositionX, newPositionY];
-            this.setPan(deltaPoint2, storeAsInitialCamera);
+        if (!displayArea) {
+            return;
         }
+        const { storeAsInitialCamera, type: areaType } = displayArea;
         if (storeAsInitialCamera) {
             this.options.displayArea = displayArea;
         }
-        if (!suppressEvents) {
+        const { _suppressCameraModifiedEvents } = this;
+        this._suppressCameraModifiedEvents = true;
+        this.setCamera(this.fitToCanvasCamera);
+        if (areaType === 'SCALE') {
+            this.setDisplayAreaScale(displayArea);
+        }
+        else {
+            this.setInterpolationType(this.getProperties()?.interpolationType || InterpolationType.LINEAR);
+            this.setDisplayAreaFit(displayArea);
+        }
+        if (storeAsInitialCamera) {
+            this.initialCamera = this.getCamera();
+        }
+        this._suppressCameraModifiedEvents = _suppressCameraModifiedEvents;
+        if (!suppressEvents && !_suppressCameraModifiedEvents) {
             const eventDetail = {
                 viewportId: this.id,
                 displayArea: displayArea,
                 storeAsInitialCamera: storeAsInitialCamera,
             };
             triggerEvent(this.element, Events.DISPLAY_AREA_MODIFIED, eventDetail);
+            this.setCamera(this.getCamera());
+        }
+    }
+    setDisplayAreaScale(displayArea) {
+        const { scale = 1 } = displayArea;
+        const canvas = this.canvas;
+        const height = canvas.height;
+        const width = canvas.width;
+        if (height < 8 || width < 8) {
+            return;
+        }
+        const imageData = this.getDefaultImageData();
+        const spacingWorld = imageData.getSpacing();
+        const spacing = spacingWorld[1];
+        this.setInterpolationType(InterpolationType.NEAREST);
+        this.setCamera({ parallelScale: (height * spacing) / (2 * scale) });
+        delete displayArea.imageArea;
+        this.setDisplayAreaFit(displayArea);
+        const { focalPoint, position, viewUp, viewPlaneNormal } = this.getCamera();
+        const focalChange = vec3.create();
+        if (canvas.height % 2) {
+            vec3.scaleAndAdd(focalChange, focalChange, viewUp, scale * 0.5 * spacing);
+        }
+        if (canvas.width % 2) {
+            const viewRight = vec3.cross(vec3.create(), viewUp, viewPlaneNormal);
+            vec3.scaleAndAdd(focalChange, focalChange, viewRight, scale * 0.5 * spacing);
+        }
+        if (!focalChange[0] && !focalChange[1] && !focalChange[2]) {
+            return;
+        }
+        this.setCamera({
+            focalPoint: vec3.add(vec3.create(), focalPoint, focalChange),
+            position: vec3.add(vec3.create(), position, focalChange),
+        });
+    }
+    setDisplayAreaFit(displayArea) {
+        const { imageArea, imageCanvasPoint } = displayArea;
+        const devicePixelRatio = window?.devicePixelRatio || 1;
+        const imageData = this.getDefaultImageData();
+        if (!imageData) {
+            return;
+        }
+        const canvasWidth = this.sWidth / devicePixelRatio;
+        const canvasHeight = this.sHeight / devicePixelRatio;
+        const dimensions = imageData.getDimensions();
+        const canvasZero = this.worldToCanvas(imageData.indexToWorld([0, 0, 0]));
+        const canvasEdge = this.worldToCanvas(imageData.indexToWorld([
+            dimensions[0] - 1,
+            dimensions[1] - 1,
+            dimensions[2],
+        ]));
+        const canvasImage = [
+            Math.abs(canvasEdge[0] - canvasZero[0]),
+            Math.abs(canvasEdge[1] - canvasZero[1]),
+        ];
+        const [imgWidth, imgHeight] = canvasImage;
+        if (imageArea) {
+            const [areaX, areaY] = imageArea;
+            const requireX = Math.abs((areaX * imgWidth) / canvasWidth);
+            const requireY = Math.abs((areaY * imgHeight) / canvasHeight);
+            const initZoom = this.getZoom();
+            const fitZoom = this.getZoom(this.fitToCanvasCamera);
+            const absZoom = Math.min(1 / requireX, 1 / requireY);
+            const applyZoom = (absZoom * initZoom) / fitZoom;
+            this.setZoom(applyZoom, false);
+        }
+        if (imageCanvasPoint) {
+            const { imagePoint, canvasPoint = imagePoint || [0.5, 0.5] } = imageCanvasPoint;
+            const [canvasX, canvasY] = canvasPoint;
+            const canvasPanX = canvasWidth * (canvasX - 0.5);
+            const canvasPanY = canvasHeight * (canvasY - 0.5);
+            const [imageX, imageY] = imagePoint || canvasPoint;
+            const useZoom = 1;
+            const imagePanX = useZoom * imgWidth * (0.5 - imageX);
+            const imagePanY = useZoom * imgHeight * (0.5 - imageY);
+            const newPositionX = imagePanX + canvasPanX;
+            const newPositionY = imagePanY + canvasPanY;
+            const deltaPoint2 = [newPositionX, newPositionY];
+            vec2.add(deltaPoint2, deltaPoint2, this.getPan());
+            this.setPan(deltaPoint2, false);
         }
     }
     getDisplayArea() {
         return this.options?.displayArea;
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true, storeAsInitialCamera = true) {
+    resetCamera(options) {
+        const { resetPan = true, resetZoom = true, resetToCenter = true, storeAsInitialCamera = true, } = options || {};
         const renderer = this.getRenderer();
-        this.setCamera({
+        this.setCameraNoEvent({
             flipHorizontal: false,
             flipVertical: false,
         });
-        const previousCamera = _cloneDeep(this.getCamera());
+        const previousCamera = structuredClone(this.getCamera());
         const bounds = renderer.computeVisiblePropBounds();
         const focalPoint = [0, 0, 0];
         const imageData = this.getDefaultImageData();
@@ -314,25 +430,13 @@ class Viewport {
         const canvasSize = [this.sWidth, this.sHeight];
         const boundsAspectRatio = widthWorld / heightWorld;
         const canvasAspectRatio = canvasSize[0] / canvasSize[1];
-        let radius;
-        if (boundsAspectRatio < canvasAspectRatio) {
-            radius = heightWorld / 2;
-        }
-        else {
-            const scaleFactor = boundsAspectRatio / canvasAspectRatio;
-            radius = (heightWorld * scaleFactor) / 2;
-        }
-        const parallelScale = 1.1 * radius;
-        let w1 = bounds[1] - bounds[0];
-        let w2 = bounds[3] - bounds[2];
-        let w3 = bounds[5] - bounds[4];
-        w1 *= w1;
-        w2 *= w2;
-        w3 *= w3;
-        radius = w1 + w2 + w3;
-        radius = radius === 0 ? 1.0 : radius;
-        radius = Math.sqrt(radius) * 0.5;
-        const distance = 1.1 * radius;
+        const scaleFactor = boundsAspectRatio / canvasAspectRatio;
+        const parallelScale = scaleFactor < 1
+            ? (this.insetImageMultiplier * heightWorld) / 2
+            : (this.insetImageMultiplier * heightWorld * scaleFactor) / 2;
+        const radius = Viewport.boundsRadius(bounds) *
+            (this.type === ViewportType.VOLUME_3D ? 10 : 1);
+        const distance = this.insetImageMultiplier * radius;
         const viewUpToSet = Math.abs(vtkMath.dot(viewUp, viewPlaneNormal)) > 0.999
             ? [-viewUp[2], viewUp[0], viewUp[1]]
             : viewUp;
@@ -357,11 +461,14 @@ class Viewport {
             viewUp: viewUpToSet,
             clippingRange: clippingRangeToUse,
         });
-        const modifiedCamera = _cloneDeep(this.getCamera());
-        this.setFitToCanvasCamera(_cloneDeep(this.getCamera()));
+        const modifiedCamera = structuredClone(this.getCamera());
+        this.setFitToCanvasCamera(structuredClone(this.getCamera()));
         if (storeAsInitialCamera) {
             this.setInitialCamera(modifiedCamera);
         }
+        if (resetZoom) {
+            this.setZoom(1, storeAsInitialCamera);
+        }
         const RESET_CAMERA_EVENT = {
             type: 'ResetCameraEvent',
             renderer,
@@ -383,20 +490,29 @@ class Viewport {
     setFitToCanvasCamera(camera) {
         this.fitToCanvasCamera = camera;
     }
-    getPan() {
+    getPan(initialCamera = this.initialCamera) {
         const activeCamera = this.getVtkActiveCamera();
         const focalPoint = activeCamera.getFocalPoint();
         const zero3 = this.canvasToWorld([0, 0]);
-        const initialCanvasFocal = this.worldToCanvas(vec3.subtract(vec3.create(), this.initialCamera.focalPoint, zero3));
-        const currentCanvasFocal = this.worldToCanvas(vec3.subtract(vec3.create(), focalPoint, zero3));
-        const result = (vec2.subtract(vec2.create(), initialCanvasFocal, currentCanvasFocal));
+        const initialCanvasFocal = this.worldToCanvas(vec3.subtract([0, 0, 0], initialCamera.focalPoint, zero3));
+        const currentCanvasFocal = this.worldToCanvas(vec3.subtract([0, 0, 0], focalPoint, zero3));
+        const result = (vec2.subtract([0, 0], initialCanvasFocal, currentCanvasFocal));
         return result;
     }
+    getCurrentImageIdIndex() {
+        throw new Error('Not implemented');
+    }
+    getSliceIndex() {
+        throw new Error('Not implemented');
+    }
+    getViewReferenceId(_specifier) {
+        return null;
+    }
     setPan(pan, storeAsInitialCamera = false) {
         const previousCamera = this.getCamera();
         const { focalPoint, position } = previousCamera;
         const zero3 = this.canvasToWorld([0, 0]);
-        const delta2 = vec2.subtract(vec2.create(), pan, this.getPan());
+        const delta2 = vec2.subtract([0, 0], pan, this.getPan());
         if (Math.abs(delta2[0]) < 1 &&
             Math.abs(delta2[1]) < 1 &&
             !storeAsInitialCamera) {
@@ -411,9 +527,12 @@ class Viewport {
             position: newPosition,
         }, storeAsInitialCamera);
     }
-    getZoom() {
+    getZoom(compareCamera = this.initialCamera) {
+        if (!compareCamera) {
+            return 1;
+        }
         const activeCamera = this.getVtkActiveCamera();
-        const { parallelScale: initialParallelScale } = this.initialCamera;
+        const { parallelScale: initialParallelScale } = compareCamera;
         return initialParallelScale / activeCamera.getParallelScale();
     }
     setZoom(value, storeAsInitialCamera = false) {
@@ -453,7 +572,7 @@ class Viewport {
         const renderer = this.getRenderer();
         return renderer.getActiveCamera();
     }
-    getCamera() {
+    getCameraNoRotation() {
         const vtkCamera = this.getVtkActiveCamera();
         return {
             viewUp: vtkCamera.getViewUp(),
@@ -467,9 +586,16 @@ class Viewport {
             flipVertical: this.flipVertical,
         };
     }
+    getCamera() {
+        const camera = this.getCameraNoRotation();
+        return {
+            ...camera,
+            rotation: this.getRotation(),
+        };
+    }
     setCamera(cameraInterface, storeAsInitialCamera = false) {
         const vtkCamera = this.getVtkActiveCamera();
-        const previousCamera = _cloneDeep(this.getCamera());
+        const previousCamera = structuredClone(this.getCamera());
         const updatedCamera = Object.assign({}, previousCamera, cameraInterface);
         const { viewUp, viewPlaneNormal, position, focalPoint, parallelScale, viewAngle, flipHorizontal, flipVertical, clippingRange, } = cameraInterface;
         if (flipHorizontal !== undefined) {
@@ -507,17 +633,39 @@ class Viewport {
         if (clippingRange !== undefined) {
             vtkCamera.setClippingRange(clippingRange);
         }
-        const actorEntry = this.getDefaultActor();
-        if (!actorEntry || !actorEntry.actor) {
-            return;
-        }
-        const isImageSlice = actorIsA(actorEntry, 'vtkImageSlice');
-        if (!isImageSlice) {
-            this.updateClippingPlanesForActors(updatedCamera);
-        }
-        else {
-            const renderer = this.getRenderer();
-            renderer.resetCameraClippingRange();
+        const prevFocalPoint = previousCamera.focalPoint;
+        const prevViewUp = previousCamera.viewUp;
+        if ((prevFocalPoint && focalPoint) || (prevViewUp && viewUp)) {
+            const currentViewPlaneNormal = vtkCamera.getViewPlaneNormal();
+            const currentViewUp = vtkCamera.getViewUp();
+            let cameraModifiedOutOfPlane = false;
+            let viewUpHasChanged = false;
+            if (focalPoint) {
+                const deltaCamera = [
+                    focalPoint[0] - prevFocalPoint[0],
+                    focalPoint[1] - prevFocalPoint[1],
+                    focalPoint[2] - prevFocalPoint[2],
+                ];
+                cameraModifiedOutOfPlane =
+                    Math.abs(vtkMath.dot(deltaCamera, currentViewPlaneNormal)) > 0;
+            }
+            if (viewUp) {
+                viewUpHasChanged = !isEqual(currentViewUp, prevViewUp);
+            }
+            if (cameraModifiedOutOfPlane || viewUpHasChanged) {
+                const actorEntry = this.getDefaultActor();
+                if (!actorEntry?.actor) {
+                    return;
+                }
+                if (!actorIsA(actorEntry, 'vtkActor')) {
+                    this.updateClippingPlanesForActors(updatedCamera);
+                }
+                if (actorIsA(actorEntry, 'vtkImageSlice') ||
+                    this.type === ViewportType.VOLUME_3D) {
+                    const renderer = this.getRenderer();
+                    renderer.resetCameraClippingRange();
+                }
+            }
         }
         if (storeAsInitialCamera) {
             this.setInitialCamera(updatedCamera);
@@ -532,25 +680,40 @@ class Viewport {
                 element: this.element,
                 viewportId: this.id,
                 renderingEngineId: this.renderingEngineId,
-                rotation: this.getRotation(),
             };
             triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
         }
     }
-    updateClippingPlanesForActors(updatedCamera) {
+    updateCameraClippingPlanesAndRange() {
+        const currentCamera = this.getCamera();
+        this.updateClippingPlanesForActors(currentCamera);
+        this.getRenderer().resetCameraClippingRange();
+    }
+    async updateClippingPlanesForActors(updatedCamera) {
         const actorEntries = this.getActors();
-        actorEntries.forEach((actorEntry) => {
+        actorEntries.map((actorEntry) => {
             if (!actorEntry.actor) {
                 return;
             }
             const mapper = actorEntry.actor.getMapper();
-            const vtkPlanes = mapper.getClippingPlanes();
+            let vtkPlanes = actorEntry?.clippingFilter
+                ? actorEntry.clippingFilter.getClippingPlanes()
+                : mapper.getClippingPlanes();
+            if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
+                vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+            }
             let slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
             if (actorEntry.slabThickness) {
                 slabThickness = actorEntry.slabThickness;
             }
             const { viewPlaneNormal, focalPoint } = updatedCamera;
             this.setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, focalPoint);
+            triggerEvent(this.element, Events.CLIPPING_PLANES_UPDATED, {
+                actorEntry,
+                focalPoint,
+                vtkPlanes,
+                viewport: this,
+            });
         });
     }
     setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, focalPoint) {
@@ -572,6 +735,22 @@ class Viewport {
         vtkMath.add(focalPoint, scaledDistance, newOrigin2);
         vtkPlanes[1].setOrigin(newOrigin2);
     }
+    getClippingPlanesForActor(actorEntry) {
+        if (!actorEntry) {
+            actorEntry = this.getDefaultActor();
+        }
+        if (!actorEntry.actor) {
+            throw new Error('Invalid actor entry: Actor is undefined');
+        }
+        const mapper = actorEntry.actor.getMapper();
+        let vtkPlanes = actorEntry?.clippingFilter
+            ? actorEntry.clippingFilter.getClippingPlanes()
+            : mapper.getClippingPlanes();
+        if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
+            vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+        }
+        return vtkPlanes;
+    }
     _getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal) {
         const viewUpCorners = this._getCorners(bounds);
         const viewRightCorners = this._getCorners(bounds);
@@ -610,6 +789,73 @@ class Viewport {
         }
         return { widthWorld: maxX - minX, heightWorld: maxY - minY };
     }
+    getViewReference(viewRefSpecifier = {}) {
+        const { focalPoint: cameraFocalPoint, viewPlaneNormal, viewUp, } = this.getCamera();
+        const target = {
+            FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            cameraFocalPoint,
+            viewPlaneNormal,
+            viewUp,
+            sliceIndex: viewRefSpecifier.sliceIndex ?? this.getSliceIndex(),
+        };
+        return target;
+    }
+    isReferenceViewable(viewRef, options) {
+        if (viewRef.FrameOfReferenceUID &&
+            viewRef.FrameOfReferenceUID !== this.getFrameOfReferenceUID()) {
+            return false;
+        }
+        const { viewPlaneNormal } = viewRef;
+        const camera = this.getCamera();
+        if (viewPlaneNormal &&
+            !isEqual(viewPlaneNormal, camera.viewPlaneNormal) &&
+            !isEqual(vec3.negate(camera.viewPlaneNormal, camera.viewPlaneNormal), viewPlaneNormal)) {
+            return options?.withOrientation === true;
+        }
+        return true;
+    }
+    getViewPresentation(viewPresSel = {
+        rotation: true,
+        displayArea: true,
+        zoom: true,
+        pan: true,
+    }) {
+        const target = {};
+        const { rotation, displayArea, zoom, pan } = viewPresSel;
+        if (rotation) {
+            target.rotation = this.getRotation();
+        }
+        if (displayArea) {
+            target.displayArea = this.getDisplayArea();
+        }
+        const initZoom = this.getZoom();
+        if (zoom) {
+            target.zoom = initZoom;
+        }
+        if (pan) {
+            target.pan = this.getPan();
+            vec2.scale(target.pan, target.pan, 1 / initZoom);
+        }
+        return target;
+    }
+    setViewReference(viewRef) {
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        const { displayArea, zoom = this.getZoom(), pan, rotation } = viewPres;
+        if (displayArea !== this.getDisplayArea()) {
+            this.setDisplayArea(displayArea);
+        }
+        this.setZoom(zoom);
+        if (pan) {
+            this.setPan(vec2.scale([0, 0], pan, zoom));
+        }
+        if (rotation >= 0) {
+            this.setRotation(rotation);
+        }
+    }
     _shouldUseNativeDataType() {
         const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
         return useNorm16Texture || preferSizeOverAccuracy;
@@ -675,6 +921,12 @@ class Viewport {
             [p7, p8],
         ];
     }
+    static boundsRadius(bounds) {
+        const w1 = (bounds[1] - bounds[0]) ** 2;
+        const w2 = (bounds[3] - bounds[2]) ** 2;
+        const w3 = (bounds[5] - bounds[4]) ** 2;
+        const radius = Math.sqrt(w1 + w2 + w3 || 1) * 0.5;
+        return radius;
+    }
 }
 export default Viewport;
-//# sourceMappingURL=Viewport.js.map

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

@@ -1,22 +1,36 @@
 import { BlendModes, OrientationAxis } from '../enums';
-import type { IVolumeInput } from '../types';
+import type { IVolumeInput, OrientationVectors, Point3, ViewReference, ViewReferenceSpecifier } from '../types';
 import type { ViewportInput } from '../types/IViewport';
 import BaseVolumeViewport from './BaseVolumeViewport';
 declare class VolumeViewport extends BaseVolumeViewport {
     private _useAcquisitionPlaneForViewPlane;
     constructor(props: ViewportInput);
     setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    getNumberOfSlices: () => number;
     addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    setOrientation(orientation: OrientationAxis, immediate?: boolean): void;
+    setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;
-    resetCamera(resetPan?: boolean, resetZoom?: boolean, resetToCenter?: boolean): boolean;
+    resetCamera(options?: any): boolean;
     setSlabThickness(slabThickness: number, filterActorUIDs?: any[]): void;
-    getCurrentImageIdIndex: () => number | undefined;
+    resetSlabThickness(): void;
+    getCurrentImageIdIndex: (volumeId?: string) => number;
+    getSliceIndex: () => number;
     getCurrentImageId: () => string | undefined;
-    getRotation: () => number;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     resetProperties(volumeId?: string): void;
     private _resetProperties;
+    getSlicesClippingPlanes(): Array<{
+        sliceIndex: number;
+        planes: Array<{
+            normal: Point3;
+            origin: Point3;
+        }>;
+    }>;
+    getSlicePlaneCoordinates: () => Array<{
+        sliceIndex: number;
+        point: Point3;
+    }>;
 }
 export default VolumeViewport;