@cornerstonejs/core 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,22 +1,49 @@
-import { BlendModes, OrientationAxis } from '../enums';
-import type { IVolumeInput } from '../types';
+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: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
-    setOrientation(orientation: OrientationAxis, immediate?: boolean): void;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    getNumberOfSlices: () => number;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
+    protected setCameraClippingRange(): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
     setBlendMode(blendMode: BlendModes, filterActorUIDs?: any[], immediate?: boolean): void;
-    resetCamera(resetPan?: boolean, resetZoom?: boolean, resetToCenter?: boolean): boolean;
+    resetCameraForResize: () => boolean;
+    resetCamera(options?: any): boolean;
     setSlabThickness(slabThickness: number, filterActorUIDs?: any[]): void;
-    getCurrentImageIdIndex: () => number | undefined;
+    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;
-    getRotation: () => number;
+    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,41 +1,88 @@
+import { mat4, vec3 } from 'gl-matrix';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
-import { vec3 } from 'gl-matrix';
-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, 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 { transformCanvasToIJK } from '../utilities/transformCanvasToIJK';
+import { transformIJKToCanvas } from '../utilities/transformIJKToCanvas';
 class VolumeViewport extends BaseVolumeViewport {
     constructor(props) {
         super(props);
         this._useAcquisitionPlaneForViewPlane = false;
-        this.getCurrentImageIdIndex = () => {
+        this.getNumberOfSlices = () => {
+            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 { origin, spacing } = this.getImageData();
-            const spacingInNormal = spacing[2];
+            const imageData = this.getImageData(volumeId);
+            if (!imageData) {
+                return;
+            }
+            const { origin, direction, spacing } = imageData;
+            const spacingInNormal = getSpacingInNormalDirection({ direction, spacing }, viewPlaneNormal);
             const sub = vec3.create();
             vec3.sub(sub, focalPoint, origin);
             const distance = vec3.dot(sub, viewPlaneNormal);
             return Math.round(Math.abs(distance) / spacingInNormal);
         };
+        this.getSliceIndex = () => {
+            const { imageIndex } = getImageSliceDataForVolumeViewport(this) || {};
+            return imageIndex;
+        };
         this.getCurrentImageId = () => {
-            if (this.getActors().length > 1) {
-                console.warn(`Using the first/default actor of ${this.getActors().length} actors for getCurrentImageId.`);
-            }
             const actorEntry = this.getDefaultActor();
             if (!actorEntry || !actorIsA(actorEntry, 'vtkVolume')) {
                 return;
             }
-            const { uid } = actorEntry;
-            const volume = cache.getVolume(uid);
+            const volume = cache.getVolume(this.getVolumeId());
             if (!volume) {
                 return;
             }
             const { viewPlaneNormal, focalPoint } = this.getCamera();
             return getClosestImageId(volume, focalPoint, viewPlaneNormal);
         };
-        this.getRotation = () => 0;
+        this.getSlicePlaneCoordinates = () => {
+            const actorEntry = this.getDefaultActor();
+            if (!actorEntry?.actor) {
+                console.warn('No image data found for calculating vtkPlanes.');
+                return [];
+            }
+            const volumeId = this.getVolumeId();
+            const imageVolume = cache.getVolume(volumeId);
+            const camera = this.getCamera();
+            const { focalPoint, position, viewPlaneNormal } = camera;
+            const spacingInNormalDirection = getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
+            const sliceRange = getSliceRange(actorEntry.actor, viewPlaneNormal, focalPoint);
+            const numSlicesBackward = Math.round((sliceRange.current - sliceRange.min) / spacingInNormalDirection);
+            const numSlicesForward = Math.round((sliceRange.max - sliceRange.current) / spacingInNormalDirection);
+            const currentSliceIndex = this.getSliceIndex();
+            const focalPoints = [];
+            for (let i = -numSlicesBackward; i <= numSlicesForward; i++) {
+                const { newFocalPoint: point } = snapFocalPointToSlice(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, i);
+                focalPoints.push({ sliceIndex: currentSliceIndex + i, point });
+            }
+            return focalPoints;
+        };
         const { orientation } = this.options;
         if (orientation && orientation !== OrientationAxis.ACQUISITION) {
             this.applyViewOrientation(orientation);
@@ -67,30 +114,46 @@ class VolumeViewport extends BaseVolumeViewport {
     }
     setOrientation(orientation, immediate = true) {
         let viewPlaneNormal, viewUp;
-        if (MPR_CAMERA_VALUES[orientation]) {
-            ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
-        }
-        else if (orientation === 'acquisition') {
-            ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+        if (typeof orientation === 'string') {
+            if (MPR_CAMERA_VALUES[orientation]) {
+                ({ viewPlaneNormal, viewUp } = MPR_CAMERA_VALUES[orientation]);
+            }
+            else if (orientation === 'acquisition') {
+                ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
+            }
+            else {
+                throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
+            }
+            this.setCamera({
+                viewPlaneNormal,
+                viewUp,
+            });
+            this.viewportProperties.orientation = orientation;
+            this.resetCamera();
         }
         else {
-            throw new Error(`Invalid orientation: ${orientation}. Use Enums.OrientationAxis instead.`);
+            ({ viewPlaneNormal, viewUp } = orientation);
+            this.applyViewOrientation(orientation);
         }
-        this.setCamera({
-            viewPlaneNormal,
-            viewUp,
-        });
-        this.resetCamera();
         if (immediate) {
             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`);
@@ -117,6 +180,7 @@ class VolumeViewport extends BaseVolumeViewport {
             viewPlaneNormal,
             viewUp,
         });
+        this.initialViewUp = viewUp;
         this.resetCamera();
     }
     setBlendMode(blendMode, filterActorUIDs = [], immediate = false) {
@@ -129,15 +193,19 @@ class VolumeViewport extends BaseVolumeViewport {
         actorEntries.forEach((actorEntry) => {
             const { actor } = actorEntry;
             const mapper = actor.getMapper();
-            mapper.setBlendMode(blendMode);
+            mapper.setBlendMode?.(blendMode);
         });
         if (immediate) {
             this.render();
         }
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true) {
-        super.resetCamera(resetPan, resetZoom, resetToCenter);
-        this.resetVolumeViewportClippingRange();
+    resetCamera(options) {
+        const { resetPan = true, resetZoom = true, resetRotation = true, resetToCenter = true, suppressEvents = false, resetOrientation = true, } = options || {};
+        const { orientation } = this.viewportProperties;
+        if (orientation && resetOrientation) {
+            this.applyViewOrientation(orientation, false);
+        }
+        super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
@@ -148,7 +216,7 @@ class VolumeViewport extends BaseVolumeViewport {
             }
             const mapper = actorEntry.actor.getMapper();
             const vtkPlanes = mapper.getClippingPlanes();
-            if (vtkPlanes.length === 0) {
+            if (vtkPlanes.length === 0 && !actorEntry?.clippingFilter) {
                 const clipPlane1 = vtkPlane.newInstance();
                 const clipPlane2 = vtkPlane.newInstance();
                 const newVtkPlanes = [clipPlane1, clipPlane2];
@@ -161,9 +229,29 @@ class VolumeViewport extends BaseVolumeViewport {
                 mapper.addClippingPlane(clipPlane2);
             }
         });
+        if (resetRotation &&
+            MPR_CAMERA_VALUES[this.viewportProperties.orientation] !== undefined) {
+            const viewToReset = MPR_CAMERA_VALUES[this.viewportProperties.orientation];
+            this.setCameraNoEvent({
+                viewUp: viewToReset.viewUp,
+                viewPlaneNormal: viewToReset.viewPlaneNormal,
+            });
+        }
+        if (!suppressEvents) {
+            const eventDetail = {
+                viewportId: this.id,
+                camera: this.getCamera(),
+                renderingEngineId: this.renderingEngineId,
+                element: this.element,
+            };
+            triggerEvent(this.element, Events.CAMERA_RESET, eventDetail);
+        }
         return true;
     }
     setSlabThickness(slabThickness, filterActorUIDs = []) {
+        if (slabThickness < 0.1) {
+            slabThickness = 0.1;
+        }
         let actorEntries = this.getActors();
         if (filterActorUIDs && filterActorUIDs.length > 0) {
             actorEntries = actorEntries.filter((actorEntry) => {
@@ -178,6 +266,96 @@ class VolumeViewport extends BaseVolumeViewport {
         const currentCamera = this.getCamera();
         this.updateClippingPlanesForActors(currentCamera);
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
+        this.viewportProperties.slabThickness = slabThickness;
+    }
+    resetSlabThickness() {
+        const actorEntries = this.getActors();
+        actorEntries.forEach((actorEntry) => {
+            if (actorIsA(actorEntry, 'vtkVolume')) {
+                actorEntry.slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+            }
+        });
+        const currentCamera = this.getCamera();
+        this.updateClippingPlanesForActors(currentCamera);
+        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) {
+            return;
+        }
+        const volume = cache.getVolume(viewRef.volumeId);
+        viewRef.referencedImageId = getClosestImageId(volume, viewRef.cameraFocalPoint, viewRef.viewPlaneNormal);
+        return viewRef;
     }
     resetProperties(volumeId) {
         this._resetProperties(volumeId);
@@ -189,25 +367,53 @@ class VolumeViewport extends BaseVolumeViewport {
         if (!volumeActor) {
             throw new Error(`No actor found for the given volumeId: ${volumeId}`);
         }
-        const imageVolume = cache.getVolume(volumeActor.uid);
+        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: ${volumeActor.uid} does not exist in cache`);
+            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);
         }
-        setDefaultVolumeVOI(volumeActor.actor, imageVolume, false);
-        const range = volumeActor.actor
-            .getProperty()
-            .getRGBTransferFunction(0)
-            .getMappingRange();
         const eventDetails = {
-            viewportId: volumeActor.uid,
-            range: {
-                lower: range[0],
-                upper: range[1],
-            },
-            volumeId: volumeActor.uid,
+            ...super.getVOIModifiedEventDetail(volumeId),
         };
+        const resetPan = true;
+        const resetZoom = true;
+        const resetToCenter = true;
+        const resetCameraRotation = true;
+        this.resetCamera({
+            resetPan,
+            resetZoom,
+            resetToCenter,
+            resetCameraRotation,
+        });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }
+    getSlicesClippingPlanes() {
+        const focalPoints = this.getSlicePlaneCoordinates();
+        const { viewPlaneNormal } = this.getCamera();
+        const slabThickness = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+        return focalPoints.map(({ point, sliceIndex }) => {
+            const vtkPlanes = [vtkPlane.newInstance(), vtkPlane.newInstance()];
+            this.setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, point);
+            return {
+                sliceIndex,
+                planes: vtkPlanes.map((plane) => ({
+                    normal: plane.getNormal(),
+                    origin: plane.getOrigin(),
+                })),
+            };
+        });
+    }
 }
 export default VolumeViewport;
-//# sourceMappingURL=VolumeViewport.js.map

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

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

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -1,15 +1,28 @@
-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.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 +32,16 @@ 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);
+        }
+        return true;
     }
     setSlabThickness(slabThickness, filterActorUIDs) {
         return null;
@@ -31,8 +50,46 @@ 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;
+    }
+    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

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

@@ -0,0 +1,58 @@
+import type { WSIViewportProperties, Point3, Point2, ICamera, CPUIImageData, ViewportInput } from '../types';
+import { Transform } from './helpers/cpuFallback/rendering/transform';
+import Viewport from './Viewport';
+declare class WSIViewport extends Viewport {
+    modality: any;
+    protected imageIds: string[];
+    readonly uid: any;
+    readonly renderingEngineId: string;
+    private frameOfReferenceUID;
+    protected metadata: any;
+    protected metadataDicomweb: any;
+    private microscopyElement;
+    protected map: any;
+    private internalCamera;
+    private viewer;
+    private voiRange;
+    constructor(props: ViewportInput);
+    static get useCustomRenderingPipeline(): boolean;
+    private addEventListeners;
+    private removeEventListeners;
+    private elementDisabledHandler;
+    private getImageDataMetadata;
+    setFrameNumber(frame: number): Promise<void>;
+    setProperties(props: WSIViewportProperties): void;
+    getProperties: () => WSIViewportProperties;
+    resetProperties(): void;
+    protected getScalarData(): any;
+    getImageData(): CPUIImageData;
+    hasImageURI(imageURI: string): boolean;
+    setCamera(camera: ICamera): void;
+    getCurrentImageId(): string;
+    getFrameNumber(): number;
+    getCamera(): ICamera;
+    resetCamera: () => boolean;
+    getNumberOfSlices: () => number;
+    static getDicomMicroscopyViewer: () => Promise<any>;
+    getFrameOfReferenceUID: () => string;
+    resize: () => void;
+    canvasToWorld: (canvasPos: Point2) => Point3;
+    worldToCanvas: (worldPos: Point3) => Point2;
+    setDataIds(imageIds: string[]): Promise<void>;
+    setWSI(imageIds: string[], client: any): Promise<void>;
+    postrender: () => void;
+    scroll(delta: number): void;
+    getRotation: () => number;
+    protected canvasToIndex: (canvasPos: Point2) => Point2;
+    protected indexToCanvas: (indexPos: Point2) => Point2;
+    getSliceIndex(): number;
+    getView(): any;
+    private refreshRenderValues;
+    customRenderViewportToCanvas: () => void;
+    getZoom(): any;
+    setZoom(zoom: number): void;
+    protected getTransform(): Transform;
+    getViewReferenceId(): string;
+    getCurrentImageIdIndex(): number;
+}
+export default WSIViewport;