@cornerstonejs/core 2.0.0-beta.8 → 2.0.0

package/dist/esm/RenderingEngine/Viewport.js

@@ -6,10 +6,12 @@ import Events from '../enums/Events';
 import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import renderingEngineCache from './renderingEngineCache';
-import { triggerEvent, planar, isImageActor, actorIsA, isEqual, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import triggerEvent from '../utilities/triggerEvent';
+import * as planar from '../utilities/planar';
+import isEqual from '../utilities/isEqual';
 import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
-import { getConfiguration } from '../init';
 import { InterpolationType } from '../enums';
 class Viewport {
     static { this.CameraViewPresentation = {
@@ -94,7 +96,7 @@ class Viewport {
         if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
             throw new Error('Rendering engine has been destroyed');
         }
-        return renderingEngine.offscreenMultiRenderWindow.getRenderer(this.id);
+        return renderingEngine.offscreenMultiRenderWindow?.getRenderer(this.id);
     }
     render() {
         const renderingEngine = this.getRenderingEngine();
@@ -115,6 +117,9 @@ class Viewport {
             this.render();
         }
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     flip({ flipHorizontal, flipVertical }) {
         const imageData = this.getDefaultImageData();
         if (!imageData) {
@@ -194,8 +199,7 @@ class Viewport {
     }
     setActors(actors) {
         this.removeAllActors();
-        const resetCameraPanAndZoom = true;
-        this.addActors(actors, resetCameraPanAndZoom);
+        this.addActors(actors, { resetCamera: true });
     }
     _removeActor(actorUID) {
         const actorEntry = this.getActor(actorUID);
@@ -212,14 +216,23 @@ class Viewport {
             this._removeActor(actorUID);
         });
     }
-    addActors(actors, resetCameraPanAndZoom = false) {
+    addActors(actors, options = {}) {
+        const { resetCamera = false } = options;
         const renderingEngine = this.getRenderingEngine();
         if (!renderingEngine || renderingEngine.hasBeenDestroyed) {
             console.warn('Viewport::addActors::Rendering engine has not been initialized or has been destroyed');
             return;
         }
-        actors.forEach((actor) => this.addActor(actor));
-        this.resetCamera(resetCameraPanAndZoom, resetCameraPanAndZoom);
+        actors.forEach((actor) => {
+            this.addActor(actor);
+        });
+        const prevViewPresentation = this.getViewPresentation();
+        const prevViewRef = this.getViewReference();
+        this.resetCamera();
+        if (!resetCamera) {
+            this.setViewReference(prevViewRef);
+            this.setViewPresentation(prevViewPresentation);
+        }
     }
     addActor(actorEntry) {
         const { uid: actorUID, actor } = actorEntry;
@@ -391,13 +404,14 @@ class Viewport {
     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.setCameraNoEvent({
             flipHorizontal: false,
             flipVertical: false,
         });
-        const previousCamera = structuredClone(this.getCamera());
+        const previousCamera = this.getCamera();
         const bounds = renderer.computeVisiblePropBounds();
         const focalPoint = [0, 0, 0];
         const imageData = this.getDefaultImageData();
@@ -457,8 +471,8 @@ class Viewport {
             viewUp: viewUpToSet,
             clippingRange: clippingRangeToUse,
         });
-        const modifiedCamera = structuredClone(this.getCamera());
-        this.setFitToCanvasCamera(structuredClone(this.getCamera()));
+        const modifiedCamera = this.getCamera();
+        this.setFitToCanvasCamera(this.getCamera());
         if (storeAsInitialCamera) {
             this.setInitialCamera(modifiedCamera);
         }
@@ -472,11 +486,11 @@ class Viewport {
         renderer.invokeEvent(RESET_CAMERA_EVENT);
         this.triggerCameraModifiedEventIfNecessary(previousCamera, modifiedCamera);
         if (imageData &&
-            this.options?.displayArea &&
+            this.options.displayArea &&
             resetZoom &&
             resetPan &&
             resetToCenter) {
-            this.setDisplayArea(this.options?.displayArea);
+            this.setDisplayArea(this.options.displayArea);
         }
         return true;
     }
@@ -487,12 +501,15 @@ class Viewport {
         this.fitToCanvasCamera = camera;
     }
     getPan(initialCamera = this.initialCamera) {
+        if (!initialCamera) {
+            return [0, 0];
+        }
         const activeCamera = this.getVtkActiveCamera();
         const focalPoint = activeCamera.getFocalPoint();
         const zero3 = this.canvasToWorld([0, 0]);
         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));
+        const result = vec2.subtract([0, 0], initialCanvasFocal, currentCanvasFocal);
         return result;
     }
     getCurrentImageIdIndex() {
@@ -501,7 +518,10 @@ class Viewport {
     getSliceIndex() {
         throw new Error('Not implemented');
     }
-    getReferenceId(_specifier) {
+    getImageData() {
+        throw new Error('Not implemented');
+    }
+    getViewReferenceId(_specifier) {
         return null;
     }
     setPan(pan, storeAsInitialCamera = false) {
@@ -568,13 +588,13 @@ class Viewport {
         const renderer = this.getRenderer();
         return renderer.getActiveCamera();
     }
-    getCamera() {
+    getCameraNoRotation() {
         const vtkCamera = this.getVtkActiveCamera();
         return {
-            viewUp: vtkCamera.getViewUp(),
-            viewPlaneNormal: vtkCamera.getViewPlaneNormal(),
-            position: vtkCamera.getPosition(),
-            focalPoint: vtkCamera.getFocalPoint(),
+            viewUp: [...vtkCamera.getViewUp()],
+            viewPlaneNormal: [...vtkCamera.getViewPlaneNormal()],
+            position: [...vtkCamera.getPosition()],
+            focalPoint: [...vtkCamera.getFocalPoint()],
             parallelProjection: vtkCamera.getParallelProjection(),
             parallelScale: vtkCamera.getParallelScale(),
             viewAngle: vtkCamera.getViewAngle(),
@@ -582,9 +602,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 = structuredClone(this.getCamera());
+        const previousCamera = this.getCamera();
         const updatedCamera = Object.assign({}, previousCamera, cameraInterface);
         const { viewUp, viewPlaneNormal, position, focalPoint, parallelScale, viewAngle, flipHorizontal, flipVertical, clippingRange, } = cameraInterface;
         if (flipHorizontal !== undefined) {
@@ -669,7 +696,6 @@ class Viewport {
                 element: this.element,
                 viewportId: this.id,
                 renderingEngineId: this.renderingEngineId,
-                rotation: this.getRotation(),
             };
             triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
         }
@@ -687,7 +713,7 @@ class Viewport {
             }
             const mapper = actorEntry.actor.getMapper();
             let vtkPlanes = actorEntry?.clippingFilter
-                ? actorEntry.clippingFilter.getClippingPlanes()
+                ? actorEntry?.clippingFilter.getClippingPlanes()
                 : mapper.getClippingPlanes();
             if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
                 vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
@@ -734,7 +760,7 @@ class Viewport {
         }
         const mapper = actorEntry.actor.getMapper();
         let vtkPlanes = actorEntry?.clippingFilter
-            ? actorEntry.clippingFilter.getClippingPlanes()
+            ? actorEntry?.clippingFilter.getClippingPlanes()
             : mapper.getClippingPlanes();
         if (vtkPlanes.length === 0 && actorEntry?.clippingFilter) {
             vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
@@ -800,7 +826,7 @@ class Viewport {
         if (viewPlaneNormal &&
             !isEqual(viewPlaneNormal, camera.viewPlaneNormal) &&
             !isEqual(vec3.negate(camera.viewPlaneNormal, camera.viewPlaneNormal), viewPlaneNormal)) {
-            return options?.withOrientation === true;
+            return options?.withOrientation;
         }
         return true;
     }
@@ -846,10 +872,6 @@ class Viewport {
             this.setRotation(rotation);
         }
     }
-    _shouldUseNativeDataType() {
-        const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-        return useNorm16Texture || preferSizeOverAccuracy;
-    }
     _getCorners(bounds) {
         return [
             [bounds[0], bounds[2], bounds[4]],
@@ -918,6 +940,8 @@ class Viewport {
         const radius = Math.sqrt(w1 + w2 + w3 || 1) * 0.5;
         return radius;
     }
+    setDataIds(_imageIds, _options) {
+        throw new Error('Unsupported operatoin setDataIds');
+    }
 }
 export default Viewport;
-//# sourceMappingURL=Viewport.js.map

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

@@ -0,0 +1,50 @@
+import { mat4 } from 'gl-matrix';
+import type { BlendModes } from '../enums';
+import { OrientationAxis } from '../enums';
+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: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    getNumberOfSlices: () => number;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    jumpToWorld(worldPos: Point3): boolean;
+    setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
+    protected setCameraClippingRange(): void;
+    private _getAcquisitionPlaneOrientation;
+    private _setViewPlaneToAcquisitionPlane;
+    setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;
+    resetCameraForResize: () => boolean;
+    resetCamera(options?: any): boolean;
+    setSlabThickness(slabThickness: number, filterActorUIDs?: any[]): void;
+    resetSlabThickness(): void;
+    getCurrentImageIdIndex: (volumeId?: string) => number;
+    getSliceIndex: () => number;
+    getSliceViewInfo(): {
+        sliceIndex: number;
+        slicePlane: number;
+        width: number;
+        height: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
+    getCurrentSlicePixelData(): import("../types").PixelDataTypedArray;
+    getCurrentImageId: () => string | undefined;
+    getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    resetProperties(volumeId?: string): void;
+    private _resetProperties;
+    getSlicesClippingPlanes(): {
+        sliceIndex: number;
+        planes: {
+            normal: Point3;
+            origin: Point3;
+        }[];
+    }[];
+    getSlicePlaneCoordinates: () => {
+        sliceIndex: number;
+        point: Point3;
+    }[];
+}
+export default VolumeViewport;

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -1,21 +1,37 @@
+import { mat4, vec3 } from 'gl-matrix';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
-import cache from '../cache';
-import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
+import cache from '../cache/cache';
+import { EPSILON, MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
 import { OrientationAxis, Events } from '../enums';
-import { actorIsA, getClosestImageId, getSliceRange, getSpacingInNormalDirection, isImageActor, snapFocalPointToSlice, triggerEvent, } from '../utilities';
+import { actorIsA, isImageActor } from '../utilities/actorCheck';
+import getClosestImageId from '../utilities/getClosestImageId';
+import getSliceRange from '../utilities/getSliceRange';
+import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirection';
+import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
+import triggerEvent from '../utilities/triggerEvent';
 import BaseVolumeViewport from './BaseVolumeViewport';
 import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
 import { setTransferFunctionNodes } from '../utilities/transferFunctionUtils';
 import getImageSliceDataForVolumeViewport from '../utilities/getImageSliceDataForVolumeViewport';
-import { vec3 } from 'gl-matrix';
+import { transformCanvasToIJK } from '../utilities/transformCanvasToIJK';
+import { transformIJKToCanvas } from '../utilities/transformIJKToCanvas';
 class VolumeViewport extends BaseVolumeViewport {
     constructor(props) {
         super(props);
         this._useAcquisitionPlaneForViewPlane = false;
         this.getNumberOfSlices = () => {
-            const { numberOfSlices } = getImageSliceDataForVolumeViewport(this);
+            const { numberOfSlices } = getImageSliceDataForVolumeViewport(this) || {};
             return numberOfSlices;
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+                resetRotation: false,
+                suppressEvents: true,
+            });
+        };
         this.getCurrentImageIdIndex = (volumeId) => {
             const { viewPlaneNormal, focalPoint } = this.getCamera();
             const imageData = this.getImageData(volumeId);
@@ -30,7 +46,7 @@ class VolumeViewport extends BaseVolumeViewport {
             return Math.round(Math.abs(distance) / spacingInNormal);
         };
         this.getSliceIndex = () => {
-            const { imageIndex } = getImageSliceDataForVolumeViewport(this);
+            const { imageIndex } = getImageSliceDataForVolumeViewport(this) || {};
             return imageIndex;
         };
         this.getCurrentImageId = () => {
@@ -38,8 +54,7 @@ class VolumeViewport extends BaseVolumeViewport {
             if (!actorEntry || !actorIsA(actorEntry, 'vtkVolume')) {
                 return;
             }
-            const { uid } = actorEntry;
-            const volume = cache.getVolume(uid);
+            const volume = cache.getVolume(this.getVolumeId());
             if (!volume) {
                 return;
             }
@@ -52,7 +67,7 @@ class VolumeViewport extends BaseVolumeViewport {
                 console.warn('No image data found for calculating vtkPlanes.');
                 return [];
             }
-            const volumeId = actorEntry.uid;
+            const volumeId = this.getVolumeId();
             const imageVolume = cache.getVolume(volumeId);
             const camera = this.getCamera();
             const { focalPoint, position, viewPlaneNormal } = camera;
@@ -97,6 +112,30 @@ class VolumeViewport extends BaseVolumeViewport {
         }
         return super.addVolumes(volumeInputArray, immediate, suppressEvents);
     }
+    jumpToWorld(worldPos) {
+        const { focalPoint } = this.getCamera();
+        const delta = [0, 0, 0];
+        vec3.sub(delta, worldPos, focalPoint);
+        const camera = this.getCamera();
+        const normal = camera.viewPlaneNormal;
+        const dotProd = vec3.dot(delta, normal);
+        const projectedDelta = vec3.fromValues(normal[0], normal[1], normal[2]);
+        vec3.scale(projectedDelta, projectedDelta, dotProd);
+        if (Math.abs(projectedDelta[0]) > 1e-3 ||
+            Math.abs(projectedDelta[1]) > 1e-3 ||
+            Math.abs(projectedDelta[2]) > 1e-3) {
+            const newFocalPoint = [0, 0, 0];
+            const newPosition = [0, 0, 0];
+            vec3.add(newFocalPoint, camera.focalPoint, projectedDelta);
+            vec3.add(newPosition, camera.position, projectedDelta);
+            this.setCamera({
+                focalPoint: newFocalPoint,
+                position: newPosition,
+            });
+            this.render();
+        }
+        return true;
+    }
     setOrientation(orientation, immediate = true) {
         let viewPlaneNormal, viewUp;
         if (typeof orientation === 'string') {
@@ -124,12 +163,21 @@ class VolumeViewport extends BaseVolumeViewport {
             this.render();
         }
     }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(activeCamera.getDistance(), activeCamera.getDistance() + this.getSlabThickness());
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     _getAcquisitionPlaneOrientation() {
         const actorEntry = this.getDefaultActor();
         if (!actorEntry) {
             return;
         }
-        const volumeId = actorEntry.uid;
+        const volumeId = this.getVolumeId();
         const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
@@ -175,13 +223,13 @@ class VolumeViewport extends BaseVolumeViewport {
             this.render();
         }
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true, resetRotation = false, supressEvents = false) {
+    resetCamera(options) {
+        const { resetPan = true, resetZoom = true, resetRotation = true, resetToCenter = true, suppressEvents = false, resetOrientation = true, } = options || {};
         const { orientation } = this.viewportProperties;
-        if (orientation) {
+        if (orientation && resetOrientation) {
             this.applyViewOrientation(orientation, false);
         }
-        super.resetCamera(resetPan, resetZoom, resetToCenter);
-        this.resetVolumeViewportClippingRange();
+        super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
@@ -213,7 +261,7 @@ class VolumeViewport extends BaseVolumeViewport {
                 viewPlaneNormal: viewToReset.viewPlaneNormal,
             });
         }
-        if (!supressEvents) {
+        if (!suppressEvents) {
             const eventDetail = {
                 viewportId: this.id,
                 camera: this.getCamera(),
@@ -256,6 +304,74 @@ class VolumeViewport extends BaseVolumeViewport {
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
         this.viewportProperties.slabThickness = undefined;
     }
+    getSliceViewInfo() {
+        const { width: canvasWidth, height: canvasHeight } = this.getCanvas();
+        const ijkOriginPoint = transformCanvasToIJK(this, [0, 0]);
+        const ijkRowPoint = transformCanvasToIJK(this, [canvasWidth - 1, 0]);
+        const ijkColPoint = transformCanvasToIJK(this, [0, canvasHeight - 1]);
+        const ijkRowVec = vec3.sub(vec3.create(), ijkRowPoint, ijkOriginPoint);
+        const ijkColVec = vec3.sub(vec3.create(), ijkColPoint, ijkOriginPoint);
+        const ijkSliceVec = vec3.cross(vec3.create(), ijkRowVec, ijkColVec);
+        vec3.normalize(ijkRowVec, ijkRowVec);
+        vec3.normalize(ijkColVec, ijkColVec);
+        vec3.normalize(ijkSliceVec, ijkSliceVec);
+        const { dimensions } = this.getImageData();
+        const [sx, sy, sz] = dimensions;
+        const ijkCorners = [
+            [0, 0, 0],
+            [sx - 1, 0, 0],
+            [0, sy - 1, 0],
+            [sx - 1, sy - 1, 0],
+            [0, 0, sz - 1],
+            [sx - 1, 0, sz - 1],
+            [0, sy - 1, sz - 1],
+            [sx - 1, sy - 1, sz - 1],
+        ];
+        const canvasCorners = ijkCorners.map((ijkCorner) => transformIJKToCanvas(this, ijkCorner));
+        const canvasAABB = canvasCorners.reduce((aabb, canvasPoint) => {
+            aabb.minX = Math.min(aabb.minX, canvasPoint[0]);
+            aabb.minY = Math.min(aabb.minY, canvasPoint[1]);
+            aabb.maxX = Math.max(aabb.maxX, canvasPoint[0]);
+            aabb.maxY = Math.max(aabb.maxY, canvasPoint[1]);
+            return aabb;
+        }, { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity });
+        const ijkTopLeft = transformCanvasToIJK(this, [
+            canvasAABB.minX,
+            canvasAABB.minY,
+        ]);
+        const sliceToIndexMatrix = mat4.fromValues(ijkRowVec[0], ijkRowVec[1], ijkRowVec[2], 0, ijkColVec[0], ijkColVec[1], ijkColVec[2], 0, ijkSliceVec[0], ijkSliceVec[1], ijkSliceVec[2], 0, ijkTopLeft[0], ijkTopLeft[1], ijkTopLeft[2], 1);
+        const ijkBottomRight = transformCanvasToIJK(this, [
+            canvasAABB.maxX,
+            canvasAABB.maxY,
+        ]);
+        const ijkDiagonal = vec3.sub(vec3.create(), ijkBottomRight, ijkTopLeft);
+        const indexToSliceMatrix = mat4.invert(mat4.create(), sliceToIndexMatrix);
+        const { viewPlaneNormal } = this.getCamera();
+        const isOblique = viewPlaneNormal.filter((component) => Math.abs(component) > EPSILON)
+            .length > 1;
+        if (isOblique) {
+            throw new Error('getSliceInfo is not supported for oblique views');
+        }
+        const sliceAxis = viewPlaneNormal.findIndex((component) => Math.abs(component) > 1 - EPSILON);
+        if (sliceAxis === -1) {
+            throw new Error('Unable to determine slice axis');
+        }
+        const sliceWidth = vec3.dot(ijkRowVec, ijkDiagonal) + 1;
+        const sliceHeight = vec3.dot(ijkColVec, ijkDiagonal) + 1;
+        return {
+            sliceIndex: this.getSliceIndex(),
+            width: sliceWidth,
+            height: sliceHeight,
+            slicePlane: sliceAxis,
+            sliceToIndexMatrix,
+            indexToSliceMatrix,
+        };
+    }
+    getCurrentSlicePixelData() {
+        const { voxelManager } = this.getImageData();
+        const sliceData = voxelManager.getSliceData(this.getSliceViewInfo());
+        return sliceData;
+    }
     getViewReference(viewRefSpecifier = {}) {
         const viewRef = super.getViewReference(viewRefSpecifier);
         if (!viewRef?.volumeId) {
@@ -280,11 +396,12 @@ class VolumeViewport extends BaseVolumeViewport {
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
         if (!imageVolume) {
-            throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
-        setDefaultVolumeVOI(volumeActor.actor, imageVolume, false);
+        setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
             const transferFunction = volumeActor.actor
                 .getProperty()
@@ -298,7 +415,12 @@ class VolumeViewport extends BaseVolumeViewport {
         const resetZoom = true;
         const resetToCenter = true;
         const resetCameraRotation = true;
-        this.resetCamera(resetPan, resetZoom, resetToCenter, resetCameraRotation);
+        this.resetCamera({
+            resetPan,
+            resetZoom,
+            resetToCenter,
+            resetCameraRotation,
+        });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }
     getSlicesClippingPlanes() {
@@ -319,4 +441,3 @@ class VolumeViewport extends BaseVolumeViewport {
     }
 }
 export default VolumeViewport;
-//# sourceMappingURL=VolumeViewport.js.map

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

@@ -0,0 +1,24 @@
+import type { BlendModes } from '../enums';
+import type { ViewportInput } from '../types/IViewport';
+import BaseVolumeViewport from './BaseVolumeViewport';
+declare class VolumeViewport3D extends BaseVolumeViewport {
+    constructor(props: ViewportInput);
+    getNumberOfSlices: () => number;
+    resetCamera({ resetPan, resetZoom, resetToCenter, }?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+    }): boolean;
+    getRotation: () => number;
+    getCurrentImageIdIndex: () => number;
+    getCurrentImageId: () => string;
+    setSlabThickness(slabThickness: number, filterActorUIDs?: string[]): void;
+    setBlendMode(blendMode: BlendModes, filterActorUIDs?: string[], immediate?: boolean): void;
+    resetProperties(volumeId?: string): void;
+    resetCameraForResize: () => boolean;
+    getSliceIndex(): number;
+    setCamera(props: any): void;
+    protected setCameraClippingRange(): void;
+    resetSlabThickness(): void;
+}
+export default VolumeViewport3D;

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -1,15 +1,31 @@
-import { OrientationAxis } from '../enums';
+import { RENDERING_DEFAULTS } from '../constants';
+import { OrientationAxis, Events } from '../enums';
+import cache from '../cache/cache';
+import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
+import triggerEvent from '../utilities/triggerEvent';
+import { isImageActor } from '../utilities/actorCheck';
+import { setTransferFunctionNodes } from '../utilities/transferFunctionUtils';
 import BaseVolumeViewport from './BaseVolumeViewport';
 class VolumeViewport3D extends BaseVolumeViewport {
     constructor(props) {
         super(props);
+        this.getNumberOfSlices = () => {
+            return 1;
+        };
         this.getRotation = () => 0;
         this.getCurrentImageIdIndex = () => {
-            return undefined;
+            return 0;
         };
         this.getCurrentImageId = () => {
             return null;
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+            });
+        };
         const { parallelProjection, orientation } = this.options;
         const activeCamera = this.getVtkActiveCamera();
         if (parallelProjection != null) {
@@ -19,10 +35,18 @@ class VolumeViewport3D extends BaseVolumeViewport {
             this.applyViewOrientation(orientation);
         }
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true) {
-        super.resetCamera(resetPan, resetZoom, resetToCenter);
-        this.resetVolumeViewportClippingRange();
-        return;
+    resetCamera({ resetPan = true, resetZoom = true, resetToCenter = true, } = {}) {
+        super.resetCamera({ resetPan, resetZoom, resetToCenter });
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+        const renderer = this.getRenderer();
+        renderer.resetCameraClippingRange();
+        return true;
     }
     setSlabThickness(slabThickness, filterActorUIDs) {
         return null;
@@ -31,11 +55,51 @@ class VolumeViewport3D extends BaseVolumeViewport {
         return null;
     }
     resetProperties(volumeId) {
+        const volumeActor = volumeId
+            ? this.getActor(volumeId)
+            : this.getDefaultActor();
+        if (!volumeActor) {
+            throw new Error(`No actor found for the given volumeId: ${volumeId}`);
+        }
+        if (volumeActor.slabThickness) {
+            volumeActor.slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+            this.viewportProperties.slabThickness = undefined;
+            this.updateClippingPlanesForActors(this.getCamera());
+        }
+        volumeId ||= this.getVolumeId();
+        const imageVolume = cache.getVolume(volumeId);
+        if (!imageVolume) {
+            throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
+        }
+        setDefaultVolumeVOI(volumeActor.actor, imageVolume);
+        if (isImageActor(volumeActor)) {
+            const transferFunction = volumeActor.actor
+                .getProperty()
+                .getRGBTransferFunction(0);
+            setTransferFunctionNodes(transferFunction, this.initialTransferFunctionNodes);
+        }
+        this.setCamera(this.initialCamera);
+        triggerEvent(this.element, Events.VOI_MODIFIED, super.getVOIModifiedEventDetail(volumeId));
+    }
+    getSliceIndex() {
         return null;
     }
+    setCamera(props) {
+        super.setCamera(props);
+        this.getRenderer().resetCameraClippingRange();
+        this.render();
+    }
+    setCameraClippingRange() {
+        const activeCamera = this.getVtkActiveCamera();
+        if (activeCamera.getParallelProjection()) {
+            activeCamera.setClippingRange(-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+        else {
+            activeCamera.setClippingRange(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE);
+        }
+    }
     resetSlabThickness() {
         return null;
     }
 }
 export default VolumeViewport3D;
-//# sourceMappingURL=VolumeViewport3D.js.map