@cornerstonejs/core 2.0.0-beta.23 → 2.0.0-beta.25

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

@@ -1,11 +1,11 @@
 import type { mat4 } from 'gl-matrix';
 import type { BlendModes, InterpolationType, OrientationAxis } from '../enums';
-import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference, IVolumeViewport } from '../types';
+import type { FlipDirection, IImageData, IVolumeInput, OrientationVectors, Point2, Point3, VolumeViewportProperties, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewReference } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
 import type { ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
 import Viewport from './Viewport';
-declare abstract class BaseVolumeViewport extends Viewport implements IVolumeViewport {
+declare abstract class BaseVolumeViewport extends Viewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;
     protected initialTransferFunctionNodes: TransferFunctionNodes;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -419,6 +419,7 @@ class BaseVolumeViewport extends Viewport {
         const volumeIdToUse = applicableVolumeActorInfo.volumeId;
         let voiRangeToUse = voiRange;
         if (typeof voiRangeToUse === 'undefined') {
+            throw new Error('voiRangeToUse is undefined, need to implement this in the new volume model');
             const imageData = volumeActor.getMapper().getInputData();
             const range = imageData.getPointData().getScalars().getRange();
             const maxVoiRange = { lower: range[0], upper: range[1] };
@@ -617,6 +618,9 @@ class BaseVolumeViewport extends Viewport {
             this.setSlabThickness(properties.slabThickness);
             this.viewportProperties.slabThickness = properties.slabThickness;
         }
+        if (properties.preset !== undefined) {
+            this.setPreset(properties.preset, volumeId, false);
+        }
         this.render();
     }
     setPreset(presetNameOrObj, volumeId, suppressEvents) {

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

@@ -1,8 +1,7 @@
 import type { IViewport } from '../../types/IViewport';
-import type { ICanvasActor } from '../../types/IActor';
 import CanvasProperties from './CanvasProperties';
 import CanvasMapper from './CanvasMapper';
-export default class CanvasActor implements ICanvasActor {
+export default class CanvasActor {
     private image;
     private derivedImage;
     private canvasProperties;

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

@@ -1,8 +1,7 @@
 import type IStackViewport from '../types/IStackViewport';
-import type IRenderingEngine from '../types/IRenderingEngine';
 import type IVolumeViewport from '../types/IVolumeViewport';
 import type { PublicViewportInput, IViewport } from '../types/IViewport';
-declare class RenderingEngine implements IRenderingEngine {
+declare class RenderingEngine {
     readonly id: string;
     hasBeenDestroyed: boolean;
     offscreenMultiRenderWindow: any;

package/dist/esm/RenderingEngine/RenderingEngine.js

@@ -287,18 +287,7 @@ class RenderingEngine {
             const prevCamera = vp.getCamera();
             const rotation = vp.getRotation();
             const { flipHorizontal } = prevCamera;
-            const resetPan = true;
-            const resetZoom = true;
-            const resetToCenter = true;
-            const resetRotation = false;
-            const suppressEvents = true;
-            vp.resetCamera({
-                resetPan,
-                resetZoom,
-                resetToCenter,
-                resetRotation,
-                suppressEvents,
-            });
+            vp.resetCameraForResize();
             const displayArea = vp.getDisplayArea();
             if (keepCamera) {
                 if (displayArea) {

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

@@ -1,6 +1,6 @@
 import type { vtkImageData as vtkImageDataType } from '@kitware/vtk.js/Common/DataModel/ImageData';
 import { mat4 } from 'gl-matrix';
-import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, IStackViewport, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput, ImagePixelModule, ImagePlaneModule } from '../types';
+import type { ActorEntry, CPUIImageData, ICamera, IImage, IImageData, IImagesLoader, IStackInput, ImageLoadListener, Mat3, Point2, Point3, Scaling, StackViewportProperties, ViewReference, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewportInput, ImagePixelModule, ImagePlaneModule } from '../types';
 import Viewport from './Viewport';
 import { InterpolationType, RequestType, ViewportStatus } from '../enums';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
@@ -15,7 +15,7 @@ export interface ImageDataMetaData {
     imagePlaneModule: ImagePlaneModule;
     imagePixelModule: ImagePixelModule;
 }
-declare class StackViewport extends Viewport implements IStackViewport, IImagesLoader {
+declare class StackViewport extends Viewport {
     private imageIds;
     private currentImageIdIndex;
     private targetImageIdIndex;
@@ -57,7 +57,12 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     setCamera: (cameraInterface: ICamera, storeAsInitialCamera?: boolean) => void;
     getRotation: () => number;
     unsetColormap: () => void;
-    resetCamera: (options?: any) => boolean;
+    resetCamera: (options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+        suppressEvents?: boolean;
+    }) => boolean;
     canvasToWorld: (canvasPos: Point2) => Point3;
     worldToCanvas: (worldPos: Point3) => Point2;
     getRenderer: () => vtkRenderer;
@@ -88,6 +93,7 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, }?: StackViewportProperties, suppressEvents?: boolean): void;
     getDefaultProperties: (imageId?: string) => StackViewportProperties;
     getProperties: () => StackViewportProperties;
+    resetCameraForResize: () => boolean;
     resetProperties(): void;
     private _resetProperties;
     resetToDefaultProperties(): void;
@@ -115,6 +121,7 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
     private _addScalingToViewport;
     private _getNumCompsFromPhotometricInterpretation;
     getImageDataMetadata(image: IImage): ImageDataMetaData;
+    private matchImagesForOverlay;
     getImagePlaneReferenceData(sliceIndex?: number): ViewReference;
     private _getCameraOrientation;
     createVTKImageData({ origin, direction, dimensions, spacing, numberOfComponents, pixelArray, }: {
@@ -187,7 +194,7 @@ declare class StackViewport extends Viewport implements IStackViewport, IImagesL
         width: number;
         height: number;
     };
-    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean | unknown;
+    isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
     setViewReference(viewRef: ViewReference): void;
     getViewReferenceId(specifier?: ViewReferenceSpecifier): string;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -103,6 +103,14 @@ class StackViewport extends Viewport {
                 isComputedVOI: !voiUpdatedWithSetProperties,
             };
         };
+        this.resetCameraForResize = () => {
+            return this.resetCamera({
+                resetPan: true,
+                resetZoom: true,
+                resetToCenter: true,
+                suppressEvents: true,
+            });
+        };
         this.getRotationCPU = () => {
             const { viewport } = this._cpuFallbackEnabledElement;
             return viewport.rotation;
@@ -317,12 +325,14 @@ class StackViewport extends Viewport {
                 gpu: this.setInvertColorGPU,
             },
             resetCamera: {
-                cpu: (resetPan = true, resetZoom = true) => {
-                    this.resetCameraCPU(resetPan, resetZoom);
+                cpu: (options = {}) => {
+                    const { resetPan = true, resetZoom = true } = options;
+                    this.resetCameraCPU({ resetPan, resetZoom });
                     return true;
                 },
-                gpu: (resetPan = true, resetZoom = true) => {
-                    this.resetCameraGPU(resetPan, resetZoom);
+                gpu: (options = {}) => {
+                    const { resetPan = true, resetZoom = true } = options;
+                    this.resetCameraGPU({ resetPan, resetZoom });
                     return true;
                 },
             },
@@ -1035,6 +1045,43 @@ class StackViewport extends Viewport {
             imagePixelModule,
         };
     }
+    matchImagesForOverlay(currentImageId, referencedImageId) {
+        const matchImagesForOverlay = (targetImageId) => {
+            const referenceImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
+            const currentImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetImageId);
+            const referenceOrientation = referenceImagePlaneModule.imageOrientationPatient;
+            const currentOrientation = currentImagePlaneModule.imageOrientationPatient;
+            if (referenceOrientation && currentOrientation) {
+                const closeEnough = isEqual(referenceImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
+                if (closeEnough) {
+                    const referencePosition = referenceImagePlaneModule.imagePositionPatient;
+                    const currentPosition = currentImagePlaneModule.imagePositionPatient;
+                    if (referencePosition && currentPosition) {
+                        const vector = vec3.create();
+                        vec3.subtract(vector, currentPosition, referencePosition);
+                        const viewPlaneNormal = vec3.create();
+                        vec3.cross(viewPlaneNormal, currentOrientation.slice(0, 3), currentOrientation.slice(3, 6));
+                        const dotProduct = vec3.dot(vector, viewPlaneNormal);
+                        const isOrthogonal = Math.abs(dotProduct) < EPSILON;
+                        if (isOrthogonal) {
+                            return targetImageId;
+                        }
+                    }
+                }
+            }
+            else {
+                const referenceRows = referenceImagePlaneModule.rows;
+                const referenceColumns = referenceImagePlaneModule.columns;
+                const currentRows = currentImagePlaneModule.rows;
+                const currentColumns = currentImagePlaneModule.columns;
+                if (referenceRows === currentRows &&
+                    referenceColumns === currentColumns) {
+                    return targetImageId;
+                }
+            }
+        };
+        return matchImagesForOverlay(currentImageId);
+    }
     getImagePlaneReferenceData(sliceIndex = this.getCurrentImageIdIndex()) {
         const imageId = this.imageIds[sliceIndex];
         if (!imageId) {
@@ -1127,7 +1174,7 @@ class StackViewport extends Viewport {
             element: this.element,
             currentImageIdIndex: currentImageIdIndex,
         };
-        triggerEvent(this.element, Events.STACK_VIEWPORT_NEW_STACK, eventDetail);
+        triggerEvent(this.element, Events.VIEWPORT_NEW_IMAGE_SET, eventDetail);
         return imageId;
     }
     _throwIfDestroyed() {
@@ -1399,7 +1446,7 @@ class StackViewport extends Viewport {
     _updateActorToDisplayImageId(image) {
         const sameImageData = this._checkVTKImageDataMatchesCornerstoneImage(image, this._imageData);
         const activeCamera = this.getRenderer().getActiveCamera();
-        const previousCameraProps = structuredClone(this.getCamera());
+        const previousCameraProps = this.getCamera();
         if (sameImageData && !this.stackInvalidated) {
             this._updateVTKImageDataFromCornerstoneImage(image);
             const cameraProps = this.getCamera();
@@ -1518,7 +1565,7 @@ class StackViewport extends Viewport {
         }
         return imageId;
     }
-    resetCameraCPU(resetPan, resetZoom) {
+    resetCameraCPU({ resetPan = true, resetZoom = true, }) {
         const { image } = this._cpuFallbackEnabledElement;
         if (!image) {
             return;
@@ -1533,7 +1580,7 @@ class StackViewport extends Viewport {
             scale,
         });
     }
-    resetCameraGPU(resetPan, resetZoom) {
+    resetCameraGPU({ resetPan, resetZoom }) {
         this.setCamera({
             flipHorizontal: false,
             flipVertical: false,
@@ -1663,51 +1710,18 @@ class StackViewport extends Viewport {
             return options.asVolume;
         }
         let testIndex = this.getCurrentImageIdIndex();
-        const currentImageId = this.imageIds[testIndex];
+        let currentImageId = this.imageIds[testIndex];
         if (options.withNavigation && typeof sliceIndex === 'number') {
             testIndex = sliceIndex;
+            currentImageId = this.imageIds[testIndex];
         }
         if (!currentImageId) {
             return false;
         }
         if (options.asOverlay && referencedImageId) {
-            const matchImagesForOverlay = (targetImageId) => {
-                const referenceImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
-                const currentImagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, targetImageId);
-                const referenceOrientation = referenceImagePlaneModule.imageOrientationPatient;
-                const currentOrientation = currentImagePlaneModule.imageOrientationPatient;
-                if (referenceOrientation && currentOrientation) {
-                    const closeEnough = isEqual(referenceImagePlaneModule.imageOrientationPatient, currentImagePlaneModule.imageOrientationPatient);
-                    if (closeEnough) {
-                        const referencePosition = referenceImagePlaneModule.imagePositionPatient;
-                        const currentPosition = currentImagePlaneModule.imagePositionPatient;
-                        if (referencePosition && currentPosition) {
-                            const vector = vec3.create();
-                            vec3.subtract(vector, currentPosition, referencePosition);
-                            const viewPlaneNormal = vec3.create();
-                            vec3.cross(viewPlaneNormal, currentOrientation.slice(0, 3), currentOrientation.slice(3, 6));
-                            const dotProduct = vec3.dot(vector, viewPlaneNormal);
-                            const isOrthogonal = Math.abs(dotProduct) < EPSILON;
-                            if (isOrthogonal) {
-                                return targetImageId;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const referenceRows = referenceImagePlaneModule.rows;
-                    const referenceColumns = referenceImagePlaneModule.columns;
-                    const currentRows = currentImagePlaneModule.rows;
-                    const currentColumns = currentImagePlaneModule.columns;
-                    if (referenceRows === currentRows &&
-                        referenceColumns === currentColumns) {
-                        return targetImageId;
-                    }
-                }
-            };
-            const matchedImageId = matchImagesForOverlay(currentImageId);
+            const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
             if (matchedImageId) {
-                return matchedImageId;
+                return true;
             }
         }
         let { imageURI } = options;
@@ -1822,17 +1836,17 @@ class StackViewport extends Viewport {
     }
     _getImagePlaneModule(imageId) {
         const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
+        this.hasPixelSpacing =
+            !imagePlaneModule.usingDefaultValues || this.calibration?.scale > 0;
         this.calibration ||= imagePlaneModule.calibration;
         const newImagePlaneModule = {
             ...imagePlaneModule,
         };
         if (!newImagePlaneModule.columnPixelSpacing) {
             newImagePlaneModule.columnPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.rowPixelSpacing) {
             newImagePlaneModule.rowPixelSpacing = 1;
-            this.hasPixelSpacing = this.calibration?.scale > 0;
         }
         if (!newImagePlaneModule.columnCosines) {
             newImagePlaneModule.columnCosines = [0, 1, 0];

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

@@ -1,6 +1,6 @@
 import type { mat4 } from 'gl-matrix';
 import { VideoEnums as VideoViewportEnum } from '../enums';
-import type { IVideoViewport, VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types';
+import type { VideoViewportProperties, Point3, Point2, ICamera, VideoViewportInput, VOIRange, IImage, ViewReferenceSpecifier, ViewReference, ReferenceCompatibleOptions, ImageSetOptions, IStackInput, CPUIImageData, IImageData } from '../types';
 import { Transform } from './helpers/cpuFallback/rendering/transform';
 import Viewport from './Viewport';
 import CanvasActor from './CanvasActor';
@@ -8,7 +8,7 @@ export type CanvasScalarData = Uint8ClampedArray & {
     frameNumber?: number;
     getRange?: () => [number, number];
 };
-declare class VideoViewport extends Viewport implements IVideoViewport {
+declare class VideoViewport extends Viewport {
     static frameRangeExtractor: RegExp;
     modality: any;
     protected imageId: string;

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

@@ -4,12 +4,12 @@ import type { mat4 } from 'gl-matrix';
 import ViewportStatus from '../enums/ViewportStatus';
 import ViewportType from '../enums/ViewportType';
 import type { ICamera, ActorEntry, IRenderingEngine, ViewportInputOptions, Point2, Point3, FlipDirection, DisplayArea, ViewPresentation, ViewReference, ViewportProperties } from '../types';
-import type { ViewportInput, IViewport, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
+import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
 import type IImageCalibration from '../types/IImageCalibration';
 import { InterpolationType } from '../enums';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
-declare class Viewport implements IViewport {
+declare class Viewport {
     static readonly CameraViewPresentation: ViewPresentationSelector;
     static readonly TransferViewPresentation: ViewPresentationSelector;
     readonly id: string;
@@ -88,7 +88,12 @@ declare class Viewport implements IViewport {
     protected setDisplayAreaScale(displayArea: DisplayArea): void;
     protected setDisplayAreaFit(displayArea: DisplayArea): void;
     getDisplayArea(): DisplayArea | undefined;
-    resetCamera(options?: any): boolean;
+    resetCamera(options?: {
+        resetPan?: boolean;
+        resetZoom?: boolean;
+        resetToCenter?: boolean;
+        storeAsInitialCamera?: boolean;
+    }): boolean;
     protected setInitialCamera(camera: ICamera): void;
     protected setFitToCanvasCamera(camera: ICamera): void;
     getPan(initialCamera?: ICamera): Point2;

package/dist/esm/RenderingEngine/Viewport.js

@@ -408,7 +408,7 @@ class Viewport {
             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();
@@ -468,8 +468,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);
         }
@@ -585,10 +585,10 @@ class Viewport {
     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(),
@@ -605,7 +605,7 @@ class Viewport {
     }
     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) {

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

@@ -14,6 +14,7 @@ declare class VolumeViewport extends BaseVolumeViewport {
     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;

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -23,6 +23,15 @@ class VolumeViewport extends BaseVolumeViewport {
             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);

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

@@ -3,7 +3,11 @@ 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;
     getCurrentImageId: () => string;

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -1,5 +1,10 @@
 import { RENDERING_DEFAULTS } from '../constants';
-import { OrientationAxis } from '../enums';
+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) {
@@ -20,7 +25,7 @@ class VolumeViewport3D extends BaseVolumeViewport {
             this.applyViewOrientation(orientation);
         }
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true) {
+    resetCamera({ resetPan = true, resetZoom = true, resetToCenter = true, }) {
         super.resetCamera({ resetPan, resetZoom, resetToCenter });
         const activeCamera = this.getVtkActiveCamera();
         if (activeCamera.getParallelProjection()) {
@@ -38,7 +43,30 @@ class VolumeViewport3D extends BaseVolumeViewport {
         return null;
     }
     resetProperties(volumeId) {
-        return null;
+        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());
+        }
+        const imageVolume = cache.getVolume(volumeActor.uid);
+        if (!imageVolume) {
+            throw new Error(`imageVolume with id: ${volumeActor.uid} 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));
     }
     resetSlabThickness() {
         return null;

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

@@ -1,7 +1,7 @@
-import type { IWSIViewport, WSIViewportProperties, Point3, Point2, ICamera, WSIViewportInput, CPUIImageData } from '../types';
+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 implements IWSIViewport {
+declare class WSIViewport extends Viewport {
     modality: any;
     protected imageIds: string[];
     readonly uid: any;
@@ -14,7 +14,7 @@ declare class WSIViewport extends Viewport implements IWSIViewport {
     private internalCamera;
     private viewer;
     private voiRange;
-    constructor(props: WSIViewportInput);
+    constructor(props: ViewportInput);
     static get useCustomRenderingPipeline(): boolean;
     private addEventListeners;
     private removeEventListeners;

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

@@ -1,14 +1,8 @@
-import StackViewport from '../StackViewport';
-import VolumeViewport from '../VolumeViewport';
-import VolumeViewport3D from '../VolumeViewport3D';
-import VideoViewport from '../VideoViewport';
-import WSIViewport from '../WSIViewport';
+import type { ViewportInput, IViewport } from '../../types/IViewport';
+interface ViewportConstructor {
+    new (viewportInput: ViewportInput): IViewport;
+}
 declare const viewportTypeToViewportClass: {
-    orthographic: typeof VolumeViewport;
-    perspective: typeof VolumeViewport;
-    stack: typeof StackViewport;
-    volume3d: typeof VolumeViewport3D;
-    video: typeof VideoViewport;
-    wholeSlide: typeof WSIViewport;
+    [key: string]: ViewportConstructor;
 };
 export default viewportTypeToViewportClass;

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

@@ -10,6 +10,6 @@ const viewportTypeToViewportClass = {
     [ViewportType.STACK]: StackViewport,
     [ViewportType.VOLUME_3D]: VolumeViewport3D,
     [ViewportType.VIDEO]: VideoViewport,
-    [ViewportType.WholeSlide]: WSIViewport,
+    [ViewportType.WHOLE_SLIDE]: WSIViewport,
 };
 export default viewportTypeToViewportClass;

package/dist/esm/cache/cache.d.ts

@@ -1,5 +1,5 @@
-import type { ICache, IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
-declare class Cache implements ICache {
+import type { IImage, IGeometry, IImageLoadObject, IVolumeLoadObject, IGeometryLoadObject, ICachedImage, IImageVolume } from '../types';
+declare class Cache {
     private readonly _imageCache;
     private readonly _volumeCache;
     private readonly _geometryCache;
@@ -42,4 +42,4 @@ declare class Cache implements ICache {
 }
 declare const cache: Cache;
 export default cache;
-export { Cache };
+export { Cache, cache };

package/dist/esm/cache/cache.js

@@ -498,4 +498,4 @@ class Cache {
 }
 const cache = new Cache();
 export default cache;
-export { Cache };
+export { Cache, cache };

package/dist/esm/cache/classes/BaseStreamingImageVolume.js

@@ -7,7 +7,6 @@ import ImageVolume from './ImageVolume';
 import ProgressiveRetrieveImages from '../../loaders/ProgressiveRetrieveImages';
 import { canRenderFloatTextures } from '../../init';
 import { loadAndCacheImage } from '../../loaders/imageLoader';
-import StreamingImageVolume from './StreamingImageVolume';
 const requestTypeDefault = RequestType.Prefetch;
 export default class BaseStreamingImageVolume extends ImageVolume {
     constructor(imageVolumeProperties, streamingProperties) {

package/dist/esm/cache/classes/Contour.d.ts

@@ -1,4 +1,4 @@
-import type { Point3, ContourData, IContour } from '../../types';
+import type { Point3, ContourData } from '../../types';
 import type { ContourType } from '../../enums';
 interface ContourProps {
     id: string;
@@ -6,7 +6,7 @@ interface ContourProps {
     color: Point3;
     segmentIndex: number;
 }
-export declare class Contour implements IContour {
+export declare class Contour {
     readonly id: string;
     readonly sizeInBytes: number;
     points: Point3[];

package/dist/esm/cache/classes/ContourSet.d.ts

@@ -1,4 +1,4 @@
-import type { Point3, IContourSet, IContour, ContourData } from '../../types';
+import type { Point3, IContour, ContourData } from '../../types';
 import Contour from './Contour';
 interface ContourSetProps {
     id: string;
@@ -7,7 +7,7 @@ interface ContourSetProps {
     segmentIndex: number;
     color?: Point3;
 }
-export declare class ContourSet implements IContourSet {
+export declare class ContourSet {
     readonly id: string;
     readonly sizeInBytes: number;
     readonly frameOfReferenceUID: string;

package/dist/esm/cache/classes/ImageVolume.d.ts

@@ -1,12 +1,12 @@
 import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import type { Metadata, Point3, IImageVolume, Mat3, ImageVolumeProps, IImage, PixelDataTypedArrayString, RGB, IVoxelManager } from '../../types';
+import type { Metadata, Point3, Mat3, ImageVolumeProps, IImage, PixelDataTypedArrayString, RGB, IVoxelManager } from '../../types';
 import type vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 export interface vtkStreamingOpenGLTexture extends vtkOpenGLTexture {
     setUpdatedFrame: (frame: number) => void;
     setVolumeId: (volumeId: string) => void;
     releaseGraphicsResources: () => void;
 }
-export declare class ImageVolume implements IImageVolume {
+export declare class ImageVolume {
     private _imageIds;
     private _imageIdsIndexMap;
     private _imageURIsIndexMap;

package/dist/esm/cache/classes/Surface.d.ts

@@ -1,11 +1,11 @@
-import type { SurfaceData, Point3, ISurface, RGB } from '../../types';
+import type { SurfaceData, Point3, RGB } from '../../types';
 interface SurfaceProps {
     id: string;
     data: SurfaceData;
     frameOfReferenceUID: string;
     color?: Point3;
 }
-export declare class Surface implements ISurface {
+export declare class Surface {
     readonly id: string;
     readonly sizeInBytes: number;
     readonly frameOfReferenceUID: string;