@cornerstonejs/core 3.31.0 → 3.31.1

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

@@ -2,7 +2,7 @@ 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, ICamera } from '../types';
 import type { VoiModifiedEventDetail } from '../types/EventTypes';
-import type { ViewportInput } from '../types/IViewport';
+import type { PlaneRestriction, ViewportInput } from '../types/IViewport';
 import type { TransferFunctionNodes } from '../types/ITransferFunctionNode';
 import Viewport from './Viewport';
 import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
@@ -43,6 +43,7 @@ declare abstract class BaseVolumeViewport extends Viewport {
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     scroll(delta?: number): void;
     abstract isInAcquisitionPlane(): boolean;
+    setViewPlane(planeRestriction: PlaneRestriction, viewPlaneNormal: any): void;
     setViewReference(viewRef: ViewReference): void;
     private setThreshold;
     setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
@@ -78,6 +79,7 @@ declare abstract class BaseVolumeViewport extends Viewport {
     getRendererContextPool(): vtkRenderer;
     getRendererTiled(): vtkRenderer;
     hasImageURI: (imageURI: string) => boolean;
+    protected _getViewUp(viewPlaneNormal: any): Point3;
     protected _getOrientationVectors(orientation: OrientationAxis | OrientationVectors): OrientationVectors;
     protected _getAcquisitionPlaneOrientation(): OrientationVectors;
     getSlabThickness(): number;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -23,7 +23,7 @@ import getVolumeViewportScrollInfo from '../utilities/getVolumeViewportScrollInf
 import { actorIsA, isImageActor } from '../utilities/actorCheck';
 import snapFocalPointToSlice from '../utilities/snapFocalPointToSlice';
 import getVoiFromSigmoidRGBTransferFunction from '../utilities/getVoiFromSigmoidRGBTransferFunction';
-import isEqual, { isEqualNegative } from '../utilities/isEqual';
+import isEqual, { isEqualAbs, isEqualNegative } from '../utilities/isEqual';
 import applyPreset from '../utilities/applyPreset';
 import imageIdToURI from '../utilities/imageIdToURI';
 import uuidv4 from '../utilities/uuidv4';
@@ -257,11 +257,11 @@ class BaseVolumeViewport extends Viewport {
             const volumeActors = this.getActors().filter((actorEntry) => actorIsA(actorEntry, 'vtkVolume'));
             return volumeActors.some(({ uid, referencedId }) => {
                 const volume = cache.getVolume(referencedId || uid);
-                if (!volume?.imageIds) {
+                if (!volume?.getImageIdIndex) {
                     return false;
                 }
-                const volumeImageURIs = volume.imageIds.map(imageIdToURI);
-                return volumeImageURIs.includes(imageURI);
+                return (volume.getImageIdIndex(imageURI) !== undefined ||
+                    volume.getImageURIIndex(imageURI) !== undefined);
             });
         };
         this.getImageIds = (volumeId) => {
@@ -580,7 +580,8 @@ class BaseVolumeViewport extends Viewport {
             return false;
         }
         if (options?.withNavigation) {
-            return true;
+            const { referencedImageId } = viewRef;
+            return !referencedImageId || this.hasImageURI(referencedImageId);
         }
         const currentSliceIndex = this.getSliceIndex();
         const { sliceIndex } = viewRef;
@@ -604,14 +605,50 @@ class BaseVolumeViewport extends Viewport {
         });
         this.render();
     }
+    setViewPlane(planeRestriction, viewPlaneNormal) {
+        const { point, inPlaneVector1, inPlaneVector2, FrameOfReferenceUID } = planeRestriction;
+        if (!inPlaneVector1) {
+            return this.setViewReference({
+                FrameOfReferenceUID,
+                cameraFocalPoint: point,
+            });
+        }
+        if (inPlaneVector2) {
+            const planeNormal = (vec3.cross(vec3.create(), inPlaneVector1, inPlaneVector2));
+            vec3.normalize(planeNormal, planeNormal);
+            return this.setViewReference({
+                FrameOfReferenceUID,
+                cameraFocalPoint: point,
+                viewPlaneNormal: planeNormal,
+            });
+        }
+        const dotNormal = vec3.dot(viewPlaneNormal, inPlaneVector1);
+        if (isEqual(dotNormal, 0)) {
+            return this.setViewReference({
+                FrameOfReferenceUID,
+                viewPlaneNormal,
+                cameraFocalPoint: point,
+            });
+        }
+        const planeNormal = (vec3.cross(vec3.create(), viewPlaneNormal, inPlaneVector1));
+        vec3.normalize(planeNormal, planeNormal);
+        return this.setViewReference({
+            FrameOfReferenceUID,
+            viewPlaneNormal: planeNormal,
+            cameraFocalPoint: point,
+        });
+    }
     setViewReference(viewRef) {
         if (!viewRef) {
             return;
         }
         const volumeId = this.getVolumeId();
-        const { viewPlaneNormal: refViewPlaneNormal, FrameOfReferenceUID: refFrameOfReference, cameraFocalPoint, referencedImageId, viewUp, } = viewRef;
+        const { FrameOfReferenceUID: refFrameOfReference, cameraFocalPoint, referencedImageId, planeRestriction, viewPlaneNormal: refViewPlaneNormal, viewUp, } = viewRef;
         let { sliceIndex } = viewRef;
         const { focalPoint, viewPlaneNormal, position } = this.getCamera();
+        if (planeRestriction?.inPlaneVector1 && !refViewPlaneNormal) {
+            return this.setViewPlane(planeRestriction, viewPlaneNormal);
+        }
         const isNegativeNormal = isEqualNegative(viewPlaneNormal, refViewPlaneNormal);
         const isSameNormal = isEqual(viewPlaneNormal, refViewPlaneNormal);
         if (typeof sliceIndex === 'number' &&
@@ -969,13 +1006,35 @@ class BaseVolumeViewport extends Viewport {
         }
         return renderingEngine.offscreenMultiRenderWindow?.getRenderer(this.id);
     }
+    _getViewUp(viewPlaneNormal) {
+        const { viewUp } = this.getCamera();
+        const dot = vec3.dot(viewUp, viewPlaneNormal);
+        if (isEqual(dot, 0)) {
+            return viewUp;
+        }
+        if (isEqualAbs(viewPlaneNormal[0], 1)) {
+            return [0, 0, 1];
+        }
+        if (isEqualAbs(viewPlaneNormal[1], 1)) {
+            return [0, 0, 1];
+        }
+        if (isEqualAbs(viewPlaneNormal[2], 1)) {
+            return [0, -1, 0];
+        }
+        const vupOrthogonal = (vec3.scaleAndAdd(vec3.create(), viewUp, viewPlaneNormal, -dot));
+        vec3.normalize(vupOrthogonal, vupOrthogonal);
+        return vupOrthogonal;
+    }
     _getOrientationVectors(orientation) {
         if (typeof orientation === 'object') {
-            if (orientation.viewPlaneNormal && orientation.viewUp) {
-                return orientation;
+            if (orientation.viewPlaneNormal) {
+                return {
+                    ...orientation,
+                    viewUp: orientation.viewUp || this._getViewUp(orientation.viewPlaneNormal),
+                };
             }
             else {
-                throw new Error('Invalid orientation object. It must contain viewPlaneNormal and viewUp');
+                throw new Error('Invalid orientation object. It must contain viewPlaneNormal');
             }
         }
         else if (typeof orientation === 'string') {

package/dist/esm/RenderingEngine/StackViewport.js

@@ -1794,10 +1794,13 @@ class StackViewport extends Viewport {
                 this.imageKeyToIndexMap.get(multiSliceReference.referencedImageId);
             return testIndex <= rangeEndSliceIndex && testIndex >= foundSliceIndex;
         }
-        if (!super.isReferenceViewable(viewRef, options)) {
+        if (!super.isReferenceViewable(viewRef, {
+            ...options,
+            withOrientation: options?.asVolume,
+        })) {
             return false;
         }
-        if (viewRef.volumeId) {
+        if (viewRef.volumeId || viewRef.FrameOfReferenceUID) {
             return options.asVolume;
         }
         const { cameraFocalPoint } = viewRef;

package/dist/esm/RenderingEngine/VideoViewport.js

@@ -574,7 +574,7 @@ class VideoViewport extends Viewport {
         }
     }
     getCurrentImageId(index = this.getCurrentImageIdIndex()) {
-        const current = this.imageId.replace('/frames/1', `/frames/${index + 1}`);
+        const current = this.imageId?.replace('/frames/1', `/frames/${index + 1}`);
         return current;
     }
     getViewReferenceId(specifier = {}) {

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

@@ -4,7 +4,7 @@ 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, ImageActor } from '../types';
-import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions } from '../types/IViewport';
+import type { ViewportInput, ViewReferenceSpecifier, ReferenceCompatibleOptions, ViewPresentationSelector, DataSetOptions, PlaneRestriction } from '../types/IViewport';
 import type { vtkSlabCamera } from './vtkClasses/vtkSlabCamera';
 import type IImageCalibration from '../types/IImageCalibration';
 import { InterpolationType } from '../enums';
@@ -121,6 +121,7 @@ declare class Viewport {
     getClippingPlanesForActor(actorEntry?: ActorEntry): vtkPlane[];
     private _getWorldDistanceViewUpAndViewRight;
     getViewReference(viewRefSpecifier?: ViewReferenceSpecifier): ViewReference;
+    isPlaneViewable(planeRestriction: PlaneRestriction, options?: ReferenceCompatibleOptions): boolean;
     isReferenceViewable(viewRef: ViewReference, options?: ReferenceCompatibleOptions): boolean;
     getViewPresentation(viewPresSel?: ViewPresentationSelector): ViewPresentation;
     setViewReference(viewRef: ViewReference): void;

package/dist/esm/RenderingEngine/Viewport.js

@@ -14,6 +14,7 @@ import hasNaNValues from '../utilities/hasNaNValues';
 import { RENDERING_DEFAULTS } from '../constants';
 import { InterpolationType } from '../enums';
 import { deepClone } from '../utilities/deepClone';
+import { updatePlaneRestriction } from '../utilities/updatePlaneRestriction';
 class Viewport {
     static { this.CameraViewPresentation = {
         rotation: true,
@@ -906,16 +907,52 @@ class Viewport {
     }
     getViewReference(viewRefSpecifier) {
         const { focalPoint: cameraFocalPoint, viewPlaneNormal, viewUp, } = this.getCamera();
+        const FrameOfReferenceUID = this.getFrameOfReferenceUID();
         const target = {
-            FrameOfReferenceUID: this.getFrameOfReferenceUID(),
+            FrameOfReferenceUID,
             cameraFocalPoint,
             viewPlaneNormal,
             viewUp,
             sliceIndex: viewRefSpecifier?.sliceIndex ?? this.getSliceIndex(),
+            planeRestriction: {
+                FrameOfReferenceUID,
+                point: viewRefSpecifier?.points?.[0] || cameraFocalPoint,
+                inPlaneVector1: viewUp,
+                inPlaneVector2: (vec3.cross(vec3.create(), viewUp, viewPlaneNormal)),
+            },
         };
+        if (viewRefSpecifier?.points) {
+            updatePlaneRestriction(viewRefSpecifier.points, target.planeRestriction);
+        }
         return target;
     }
+    isPlaneViewable(planeRestriction, options) {
+        if (planeRestriction.FrameOfReferenceUID !== this.getFrameOfReferenceUID()) {
+            return false;
+        }
+        const { focalPoint, viewPlaneNormal } = this.getCamera();
+        const { point, inPlaneVector1, inPlaneVector2 } = planeRestriction;
+        if (options?.withOrientation) {
+            return true;
+        }
+        if (inPlaneVector1 &&
+            !isEqual(0, vec3.dot(viewPlaneNormal, inPlaneVector1))) {
+            return false;
+        }
+        if (inPlaneVector2 &&
+            !isEqual(0, vec3.dot(viewPlaneNormal, inPlaneVector2))) {
+            return false;
+        }
+        if (options?.withNavigation) {
+            return true;
+        }
+        const pointVector = vec3.sub(vec3.create(), point, focalPoint);
+        return isEqual(0, vec3.dot(pointVector, viewPlaneNormal));
+    }
     isReferenceViewable(viewRef, options) {
+        if (viewRef.planeRestriction) {
+            return this.isPlaneViewable(viewRef.planeRestriction, options);
+        }
         if (viewRef.FrameOfReferenceUID &&
             viewRef.FrameOfReferenceUID !== this.getFrameOfReferenceUID()) {
             return false;

package/dist/esm/types/IViewport.d.ts

@@ -24,8 +24,15 @@ export interface ReferenceCompatibleOptions {
 export type ReferencedImageRange = ViewReference & {
     referencedImageId: string;
 };
-export type ViewReference = {
+export type PlaneRestriction = {
+    FrameOfReferenceUID: string;
+    point: Point3;
+    inPlaneVector1?: Point3;
+    inPlaneVector2?: Point3;
+};
+export interface ViewReference {
     FrameOfReferenceUID?: string;
+    planeRestriction?: PlaneRestriction;
     referencedImageId?: string;
     referencedImageURI?: string;
     multiSliceReference?: ReferencedImageRange;
@@ -35,7 +42,7 @@ export type ViewReference = {
     sliceIndex?: number;
     volumeId?: string;
     bounds?: BoundsLPS;
-};
+}
 export interface ViewPresentation {
     slabThickness?: number;
     rotation?: number;

package/dist/esm/utilities/index.d.ts

@@ -94,6 +94,7 @@ export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 import getPixelSpacingInformation from './getPixelSpacingInformation';
 import { asArray } from './asArray';
+export { updatePlaneRestriction } from './updatePlaneRestriction';
 declare const getViewportModality: (viewport: IViewport, volumeId?: string) => string;
 export * from './isEqual';
 export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };

package/dist/esm/utilities/index.js

@@ -95,6 +95,7 @@ export * as logger from './logger';
 import { calculateNeighborhoodStats } from './calculateNeighborhoodStats';
 import getPixelSpacingInformation from './getPixelSpacingInformation';
 import { asArray } from './asArray';
+export { updatePlaneRestriction } from './updatePlaneRestriction';
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache.getVolume);
 export * from './isEqual';
 export { FrameRange, eventListener, csUtils as invertRgbTransferFunction, createSigmoidRGBTransferFunction, getVoiFromSigmoidRGBTransferFunction, createLinearRGBTransferFunction, scaleRgbTransferFunction, triggerEvent, imageIdToURI, fnv1aHash, calibratedPixelSpacingMetadataProvider, clamp, uuidv4, getMinMax, getRuntimeId, isOpposite, getViewportModality, windowLevel, convertToGrayscale, getClosestImageId, getSpacingInNormalDirection, getTargetVolumeAndSpacingInNormalDir, getVolumeActorCorners, indexWithinDimensions, getVolumeViewportsContainingSameVolumes, getViewportsWithVolumeId, transformWorldToIndex, transformIndexToWorld, loadImageToCanvas, renderToCanvasCPU, renderToCanvasGPU, worldToImageCoords, imageToWorldCoords, getVolumeSliceRangeInfo, getVolumeViewportScrollInfo, getSliceRange, snapFocalPointToSlice, getImageSliceDataForVolumeViewport, isImageActor, isPTPrescaledWithSUV, actorIsA, getViewportsWithImageURI, getClosestStackImageIndexForPoint, getCurrentVolumeViewportSlice, calculateViewportsSpatialRegistration, spatialRegistrationMetadataProvider, getViewportImageCornersInWorld, hasNaNValues, applyPreset, deepMerge, PointsManager, getScalingParameters, colormap, getImageLegacy, ProgressiveIterator, decimate, imageRetrieveMetadataProvider, transferFunctionUtils, updateVTKImageDataWithCornerstoneImage, sortImageIdsAndGetSpacing, makeVolumeMetadata, isValidVolume, genericMetadataProvider, isVideoTransferSyntax, HistoryMemo, generateVolumePropsFromImageIds, getBufferConfiguration, VoxelManager, RLEVoxelMap, convertStackToVolumeViewport, convertVolumeToStackViewport, roundNumber, roundToPrecision, getViewportImageIds, getRandomSampleFromArray, getVolumeId, color, hasFloatScalingParameters, getDynamicVolumeInfo, autoLoad, scaleArray, deepClone, splitImageIdsBy4DTags, pointInShapeCallback, deepEqual, jumpToSlice, scroll, clip, transformWorldToIndexContinuous, createSubVolume, getVolumeDirectionVectors, calculateSpacingBetweenImageIds, getImageDataMetadata, buildMetadata, calculateNeighborhoodStats, getPixelSpacingInformation, asArray, };

package/dist/esm/utilities/isEqual.d.ts

@@ -1,5 +1,5 @@
-export default function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
-declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
-declare function isNumber(n: number[] | number): boolean;
-export { isEqualNegative, isEqual, isEqualAbs, isNumber };
+export declare function isEqual<ValueType>(v1: ValueType, v2: ValueType, tolerance?: number): boolean;
+export declare const isEqualNegative: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+export declare const isEqualAbs: <ValueType>(v1: ValueType, v2: ValueType, tolerance?: any) => boolean;
+export declare function isNumber(n: number[] | number): boolean;
+export default isEqual;

package/dist/esm/utilities/isEqual.js

@@ -23,7 +23,7 @@ function isNumberArrayLike(value) {
         value.length > 0 &&
         typeof value[0] === 'number');
 }
-export default function isEqual(v1, v2, tolerance = 1e-5) {
+export function isEqual(v1, v2, tolerance = 1e-5) {
     if (typeof v1 !== typeof v2 || v1 === null || v2 === null) {
         return false;
     }
@@ -37,12 +37,12 @@ export default function isEqual(v1, v2, tolerance = 1e-5) {
 }
 const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
 const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
-const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
-const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
-function isNumber(n) {
+export const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
+export const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
+export function isNumber(n) {
     if (Array.isArray(n)) {
         return isNumber(n[0]);
     }
     return isFinite(n) && !isNaN(n);
 }
-export { isEqualNegative, isEqual, isEqualAbs, isNumber };
+export default isEqual;

package/dist/esm/utilities/updatePlaneRestriction.d.ts

@@ -0,0 +1,2 @@
+import type { Point3, ViewReference } from '../types';
+export declare function updatePlaneRestriction(points: Point3[], reference: ViewReference): import("../types/IViewport").PlaneRestriction;

package/dist/esm/utilities/updatePlaneRestriction.js

@@ -0,0 +1,41 @@
+import { isEqual } from '../utilities/isEqual';
+import { vec3 } from 'gl-matrix';
+const ORTHOGONAL_TEST_VALUE = 0.95;
+export function updatePlaneRestriction(points, reference) {
+    if (!points?.length || !reference.FrameOfReferenceUID) {
+        return;
+    }
+    reference.planeRestriction ||= {
+        FrameOfReferenceUID: reference.FrameOfReferenceUID,
+        point: points[0],
+        inPlaneVector1: null,
+        inPlaneVector2: null,
+    };
+    const { planeRestriction } = reference;
+    if (points.length === 1) {
+        planeRestriction.inPlaneVector1 = null;
+        planeRestriction.inPlaneVector2 = null;
+        return planeRestriction;
+    }
+    const v1 = vec3.sub(vec3.create(), points[0], points[Math.floor(points.length / 2)]);
+    vec3.normalize(v1, v1);
+    planeRestriction.inPlaneVector1 = v1;
+    planeRestriction.inPlaneVector2 = null;
+    const n = points.length;
+    if (n > 2) {
+        for (let i = Math.floor(n / 3); i < n; i++) {
+            const testVector = vec3.sub(vec3.create(), points[i], points[0]);
+            const length = vec3.length(testVector);
+            if (isEqual(length, 0)) {
+                continue;
+            }
+            if (vec3.dot(testVector, planeRestriction.inPlaneVector1) <
+                length * ORTHOGONAL_TEST_VALUE) {
+                vec3.normalize(testVector, testVector);
+                planeRestriction.inPlaneVector2 = testVector;
+                return planeRestriction;
+            }
+        }
+    }
+    return planeRestriction;
+}

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.31.0";
+export declare const version = "3.31.1";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '3.31.0';
+export const version = '3.31.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "3.31.0",
+  "version": "3.31.1",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "ea3e44970a9e535db1f38c8186653ffb7376ecf9"
+  "gitHead": "0fc65e9cc1d86a9a8b97ee9e7eb5802ce5e1e635"
 }