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

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

@@ -1,12 +1,14 @@
 import type { vtkCamera } from '@kitware/vtk.js/Rendering/Core/Camera';
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
+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 } from '../types/IViewport';
+import type { ViewportInput, IViewport, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
-import IImageCalibration from '../types/IImageCalibration';
+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 {
     static readonly CameraViewPresentation: ViewPresentationSelector;
     static readonly TransferViewPresentation: ViewPresentationSelector;
@@ -24,8 +26,8 @@ declare class Viewport implements IViewport {
     sy: number;
     sWidth: number;
     sHeight: number;
-    _actors: Map<string, any>;
-    readonly defaultOptions: Record<string, any>;
+    _actors: Map<string, ActorEntry>;
+    readonly defaultOptions: ViewportInputOptions;
     options: ViewportInputOptions;
     _suppressCameraModifiedEvents: boolean;
     readonly suppressEvents: boolean;
@@ -52,22 +54,30 @@ declare class Viewport implements IViewport {
     removeWidgets: () => void;
     setRendered(): void;
     getRenderingEngine(): IRenderingEngine;
-    getRenderer(): any;
+    getRenderer(): vtkRenderer;
     render(): void;
     setOptions(options: ViewportInputOptions, immediate?: boolean): void;
     reset(immediate?: boolean): void;
+    getSliceViewInfo(): {
+        width: number;
+        height: number;
+        sliceIndex: number;
+        slicePlane: number;
+        sliceToIndexMatrix: mat4;
+        indexToSliceMatrix: mat4;
+    };
     protected flip({ flipHorizontal, flipVertical }: FlipDirection): void;
     private getDefaultImageData;
     getDefaultActor(): ActorEntry;
-    getActors(): Array<ActorEntry>;
-    getActorUIDs(): Array<string>;
+    getActors(): ActorEntry[];
+    getActorUIDs(): string[];
     getActor(actorUID: string): ActorEntry;
     getActorUIDByIndex(index: number): string;
     getActorByIndex(index: number): ActorEntry;
-    setActors(actors: Array<ActorEntry>): void;
+    setActors(actors: ActorEntry[]): void;
     _removeActor(actorUID: string): void;
-    removeActors(actorUIDs: Array<string>): void;
-    addActors(actors: Array<ActorEntry>, resetCameraPanAndZoom?: boolean): void;
+    removeActors(actorUIDs: string[]): void;
+    addActors(actors: ActorEntry[], resetCameraPanAndZoom?: boolean): void;
     addActor(actorEntry: ActorEntry): void;
     removeAllActors(): void;
     protected resetCameraNoEvent(): void;
@@ -84,6 +94,7 @@ declare class Viewport implements IViewport {
     getPan(initialCamera?: ICamera): Point2;
     getCurrentImageIdIndex(): number;
     getSliceIndex(): number;
+    getImageData(): any;
     getViewReferenceId(_specifier?: ViewReferenceSpecifier): string;
     setPan(pan: Point2, storeAsInitialCamera?: boolean): void;
     getZoom(compareCamera?: ICamera): number;
@@ -97,7 +108,7 @@ declare class Viewport implements IViewport {
     triggerCameraModifiedEventIfNecessary(previousCamera: ICamera, updatedCamera: ICamera): void;
     updateCameraClippingPlanesAndRange(): void;
     protected updateClippingPlanesForActors(updatedCamera: ICamera): Promise<void>;
-    setOrientationOfClippingPlanes(vtkPlanes: Array<vtkPlane>, slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void;
+    setOrientationOfClippingPlanes(vtkPlanes: vtkPlane[], slabThickness: number, viewPlaneNormal: Point3, focalPoint: Point3): void;
     getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
     private _getWorldDistanceViewUpAndViewRight;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
@@ -105,14 +116,14 @@ declare class Viewport implements IViewport {
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): void;
     setViewPresentation(viewPres: ViewPresentation): void;
-    protected _shouldUseNativeDataType(): boolean;
-    _getCorners(bounds: Array<number>): Array<number>[];
+    _getCorners(bounds: number[]): number[][];
     _getFocalPointForResetCamera(centeredFocalPoint: Point3, previousCamera: ICamera, { resetPan, resetToCenter }: {
         resetPan?: boolean;
         resetToCenter?: boolean;
     }): Point3;
     _isInBounds(point: Point3, bounds: number[]): boolean;
-    _getEdges(bounds: Array<number>): Array<[number[], number[]]>;
+    _getEdges(bounds: number[]): [number[], number[]][];
     static boundsRadius(bounds: number[]): number;
+    setDataIds(_imageIds: string[], _options?: DataSetOptions): void;
 }
 export default Viewport;

package/dist/esm/RenderingEngine/Viewport.js

@@ -9,7 +9,6 @@ import renderingEngineCache from './renderingEngineCache';
 import { triggerEvent, planar, isImageActor, actorIsA, isEqual, } from '../utilities';
 import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
-import { getConfiguration } from '../init';
 import { InterpolationType } from '../enums';
 class Viewport {
     static { this.CameraViewPresentation = {
@@ -94,7 +93,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 +114,9 @@ class Viewport {
             this.render();
         }
     }
+    getSliceViewInfo() {
+        throw new Error('Method not implemented.');
+    }
     flip({ flipHorizontal, flipVertical }) {
         const imageData = this.getDefaultImageData();
         if (!imageData) {
@@ -218,7 +220,9 @@ class Viewport {
             console.warn('Viewport::addActors::Rendering engine has not been initialized or has been destroyed');
             return;
         }
-        actors.forEach((actor) => this.addActor(actor));
+        actors.forEach((actor) => {
+            this.addActor(actor);
+        });
         this.resetCamera({
             resetPan: resetCameraPanAndZoom,
             resetZoom: resetCameraPanAndZoom,
@@ -476,11 +480,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;
     }
@@ -496,7 +500,7 @@ class Viewport {
         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() {
@@ -505,6 +509,9 @@ class Viewport {
     getSliceIndex() {
         throw new Error('Not implemented');
     }
+    getImageData() {
+        throw new Error('Not implemented');
+    }
     getViewReferenceId(_specifier) {
         return null;
     }
@@ -654,7 +661,7 @@ class Viewport {
             }
             if (cameraModifiedOutOfPlane || viewUpHasChanged) {
                 const actorEntry = this.getDefaultActor();
-                if (!actorEntry?.actor) {
+                if (!actorEntry.actor) {
                     return;
                 }
                 if (!actorIsA(actorEntry, 'vtkActor')) {
@@ -697,7 +704,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()];
@@ -744,7 +751,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()];
@@ -810,7 +817,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;
     }
@@ -856,10 +863,6 @@ class Viewport {
             this.setRotation(rotation);
         }
     }
-    _shouldUseNativeDataType() {
-        const { useNorm16Texture, preferSizeOverAccuracy } = getConfiguration().rendering;
-        return useNorm16Texture || preferSizeOverAccuracy;
-    }
     _getCorners(bounds) {
         return [
             [bounds[0], bounds[2], bounds[4]],
@@ -928,5 +931,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;

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

@@ -1,13 +1,15 @@
-import { BlendModes, OrientationAxis } from '../enums';
+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';
+import { mat4 } from 'gl-matrix';
 declare class VolumeViewport extends BaseVolumeViewport {
     private _useAcquisitionPlaneForViewPlane;
     constructor(props: ViewportInput);
-    setVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    setVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     getNumberOfSlices: () => number;
-    addVolumes(volumeInputArray: Array<IVolumeInput>, immediate?: boolean, suppressEvents?: boolean): Promise<void>;
+    addVolumes(volumeInputArray: IVolumeInput[], immediate?: boolean, suppressEvents?: boolean): Promise<void>;
     setOrientation(orientation: OrientationAxis | OrientationVectors, immediate?: boolean): void;
     private _getAcquisitionPlaneOrientation;
     private _setViewPlaneToAcquisitionPlane;
@@ -17,20 +19,30 @@ declare class VolumeViewport extends BaseVolumeViewport {
     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(): Array<{
+    private setCameraClippingRange;
+    getSlicesClippingPlanes(): {
         sliceIndex: number;
-        planes: Array<{
+        planes: {
             normal: Point3;
             origin: Point3;
-        }>;
-    }>;
-    getSlicePlaneCoordinates: () => Array<{
+        }[];
+    }[];
+    getSlicePlaneCoordinates: () => {
         sliceIndex: number;
         point: Point3;
-    }>;
+    }[];
 }
 export default VolumeViewport;

package/dist/esm/RenderingEngine/VolumeViewport.js

@@ -1,19 +1,21 @@
 import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import cache from '../cache';
-import { MPR_CAMERA_VALUES, RENDERING_DEFAULTS } from '../constants';
+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 BaseVolumeViewport from './BaseVolumeViewport';
 import setDefaultVolumeVOI from './helpers/setDefaultVolumeVOI';
 import { setTransferFunctionNodes } from '../utilities/transferFunctionUtils';
 import getImageSliceDataForVolumeViewport from '../utilities/getImageSliceDataForVolumeViewport';
-import { vec3 } from 'gl-matrix';
+import { mat4, 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.getCurrentImageIdIndex = (volumeId) => {
@@ -30,7 +32,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 = () => {
@@ -176,14 +178,14 @@ class VolumeViewport extends BaseVolumeViewport {
         }
     }
     resetCamera(options) {
-        const { resetPan = true, resetZoom = true, resetRotation = true, resetToCenter = true, suppressEvents = false, } = 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();
         const activeCamera = this.getVtkActiveCamera();
+        this.setCameraClippingRange();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const focalPoint = activeCamera.getFocalPoint();
         const actorEntries = this.getActors();
@@ -242,6 +244,7 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         const currentCamera = this.getCamera();
         this.updateClippingPlanesForActors(currentCamera);
+        this.setCameraClippingRange();
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
         this.viewportProperties.slabThickness = slabThickness;
     }
@@ -257,6 +260,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) {
@@ -285,7 +356,7 @@ class VolumeViewport extends BaseVolumeViewport {
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
         }
-        setDefaultVolumeVOI(volumeActor.actor, imageVolume, false);
+        setDefaultVolumeVOI(volumeActor.actor, imageVolume);
         if (isImageActor(volumeActor)) {
             const transferFunction = volumeActor.actor
                 .getProperty()
@@ -307,6 +378,15 @@ class VolumeViewport extends BaseVolumeViewport {
         });
         triggerEvent(this.element, Events.VOI_MODIFIED, eventDetails);
     }
+    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);
+        }
+    }
     getSlicesClippingPlanes() {
         const focalPoints = this.getSlicePlaneCoordinates();
         const { viewPlaneNormal } = this.getCamera();

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

@@ -1,13 +1,13 @@
-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;
     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;
     resetSlabThickness(): void;

package/dist/esm/RenderingEngine/VolumeViewport3D.js

@@ -1,3 +1,4 @@
+import { RENDERING_DEFAULTS } from '../constants';
 import { OrientationAxis } from '../enums';
 import BaseVolumeViewport from './BaseVolumeViewport';
 class VolumeViewport3D extends BaseVolumeViewport {
@@ -5,7 +6,7 @@ class VolumeViewport3D extends BaseVolumeViewport {
         super(props);
         this.getRotation = () => 0;
         this.getCurrentImageIdIndex = () => {
-            return undefined;
+            return 0;
         };
         this.getCurrentImageId = () => {
             return null;
@@ -21,8 +22,14 @@ class VolumeViewport3D extends BaseVolumeViewport {
     }
     resetCamera(resetPan = true, resetZoom = true, resetToCenter = true) {
         super.resetCamera({ resetPan, resetZoom, resetToCenter });
-        this.resetVolumeViewportClippingRange();
-        return;
+        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;

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

@@ -0,0 +1,58 @@
+import type { IWSIViewport, WSIViewportProperties, Point3, Point2, ICamera, WSIViewportInput, CPUIImageData } from '../types';
+import { Transform } from './helpers/cpuFallback/rendering/transform';
+import Viewport from './Viewport';
+declare class WSIViewport extends Viewport implements IWSIViewport {
+    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: WSIViewportInput);
+    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;
+    getReferenceId(): string;
+    getCurrentImageIdIndex(): number;
+}
+export default WSIViewport;