@cornerstonejs/core 5.0.0-beta.1 → 5.0.1

package/dist/esm/utilities/colormap.js

@@ -4,6 +4,9 @@ import vtkPiecewiseFunction from '@kitware/vtk.js/Common/DataModel/PiecewiseFunc
 import isEqual from './isEqual';
 import { actorIsA } from './actorCheck';
 const _colormaps = new Map();
+function normalizeColormapName(name) {
+    return name?.trim().toLowerCase();
+}
 function registerColormap(colormap) {
     colormap.name = colormap.name || colormap.Name;
     _colormaps.set(colormap.name, colormap);
@@ -14,6 +17,42 @@ function getColormap(name) {
 function getColormapNames() {
     return Array.from(_colormaps.keys());
 }
+function findRegisteredColormap(name) {
+    const exactMatch = getColormap(name);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const normalizedName = normalizeColormapName(name);
+    if (!normalizedName) {
+        return;
+    }
+    for (const [registeredName, registeredColormap] of _colormaps.entries()) {
+        if (normalizeColormapName(registeredName) === normalizedName ||
+            normalizeColormapName(registeredColormap.Name) === normalizedName) {
+            return registeredColormap;
+        }
+    }
+}
+function findVTKColormap(name) {
+    const exactMatch = vtkColorMaps.getPresetByName(name);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    const normalizedName = normalizeColormapName(name);
+    if (!normalizedName) {
+        return;
+    }
+    const matchedPresetName = vtkColorMaps.rgbPresetNames.find((presetName) => normalizeColormapName(presetName) === normalizedName);
+    return matchedPresetName
+        ? vtkColorMaps.getPresetByName(matchedPresetName)
+        : undefined;
+}
+function resolveColormap(name) {
+    if (!name?.trim()) {
+        return;
+    }
+    return findRegisteredColormap(name) || findVTKColormap(name);
+}
 function findMatchingColormap(rgbPoints, actor) {
     const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) => vtkColorMaps.getPresetByName(presetName));
     const colormapsCS3D = getColormapNames().map((colormapName) => getColormap(colormapName));
@@ -34,11 +73,11 @@ function findMatchingColormap(rgbPoints, actor) {
         return null;
     }
     const opacity = [];
-    if (actorIsA(actor, 'vtkVolume')) {
+    if (actorIsA(actor, 'vtkVolume') || actorIsA(actor, 'vtkImageSlice')) {
         const opacityPoints = actor
             .getProperty()
-            .getScalarOpacity(0)
-            .getDataPointer();
+            ?.getScalarOpacity?.(0)
+            ?.getDataPointer?.();
         if (!opacityPoints) {
             return {
                 name: matchedColormap.Name,
@@ -135,4 +174,4 @@ function getMaxOpacity(volumeActor) {
     }
     return maxOpacity;
 }
-export { getColormap, getColormapNames, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };
+export { getColormap, getColormapNames, resolveColormap, registerColormap, findMatchingColormap, getThresholdValue, getMaxOpacity, };

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

@@ -0,0 +1 @@
+export declare function convertColorArrayToRgbString(colorArr: number[] | string): string;

package/dist/esm/utilities/convertColorArrayToRgbString.js

@@ -0,0 +1,5 @@
+export function convertColorArrayToRgbString(colorArr) {
+    return Array.isArray(colorArr)
+        ? `rgb(${colorArr.map((v) => Math.round(v * 255)).join(',')})`
+        : colorArr;
+}

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

@@ -1 +1 @@
-export declare function deepClone(obj: unknown): unknown;
+export declare function deepClone<T>(value: T): T;

package/dist/esm/utilities/deepClone.js

@@ -1,23 +1,52 @@
-export function deepClone(obj) {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
+export function deepClone(value) {
+    if (typeof structuredClone === 'function') {
+        try {
+            return structuredClone(value);
+        }
+        catch {
+        }
+    }
+    return cloneValue(value, new WeakMap());
+}
+function cloneValue(value, seen) {
+    if (value === null || typeof value !== 'object') {
+        return value;
     }
-    if (typeof obj === 'function') {
-        return obj;
+    const existingClone = seen.get(value);
+    if (existingClone) {
+        return existingClone;
     }
-    if (typeof structuredClone === 'function') {
-        return obj;
+    if (value instanceof Date) {
+        return new Date(value.getTime());
     }
-    if (Array.isArray(obj)) {
-        return obj.map(deepClone);
+    if (value instanceof Map) {
+        const clonedMap = new Map();
+        seen.set(value, clonedMap);
+        value.forEach((mapValue, mapKey) => {
+            clonedMap.set(cloneValue(mapKey, seen), cloneValue(mapValue, seen));
+        });
+        return clonedMap;
     }
-    else {
-        const clonedObj = {};
-        for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                clonedObj[key] = deepClone(obj[key]);
-            }
-        }
-        return clonedObj;
+    if (value instanceof Set) {
+        const clonedSet = new Set();
+        seen.set(value, clonedSet);
+        value.forEach((setValue) => {
+            clonedSet.add(cloneValue(setValue, seen));
+        });
+        return clonedSet;
+    }
+    if (Array.isArray(value)) {
+        const clonedArray = [];
+        seen.set(value, clonedArray);
+        value.forEach((item, index) => {
+            clonedArray[index] = cloneValue(item, seen);
+        });
+        return clonedArray;
     }
+    const clonedObject = {};
+    seen.set(value, clonedObject);
+    Reflect.ownKeys(value).forEach((key) => {
+        clonedObject[key] = cloneValue(value[key], seen);
+    });
+    return clonedObject;
 }

package/dist/esm/utilities/genericMetadataProvider.js

@@ -1,10 +1,11 @@
 import { addProvider } from '../metaData';
+import { deepClone } from './deepClone';
 let state = {};
 const metadataProvider = {
     add: (imageId, payload) => {
         metadataProvider.addRaw(imageId, {
             ...payload,
-            metadata: structuredClone(payload.metadata),
+            metadata: deepClone(payload.metadata),
         });
     },
     addRaw: (imageId, payload) => {

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

@@ -0,0 +1,8 @@
+declare const genericViewportDataSetMetadataProvider: {
+    VIEWPORT_V2_DATA_SET: string;
+    add(dataId: string, dataSet: unknown): void;
+    get(type: string, dataId: string): unknown;
+    remove(dataId: string): void;
+    clear(): void;
+};
+export default genericViewportDataSetMetadataProvider;

package/dist/esm/utilities/genericViewportDataSetMetadataProvider.js

@@ -0,0 +1,23 @@
+import { addProvider } from '../metaData';
+const VIEWPORT_V2_DATA_SET = 'genericViewportDataSet';
+let state = {};
+const genericViewportDataSetMetadataProvider = {
+    VIEWPORT_V2_DATA_SET,
+    add(dataId, dataSet) {
+        state[dataId] = dataSet;
+    },
+    get(type, dataId) {
+        if (type !== VIEWPORT_V2_DATA_SET) {
+            return;
+        }
+        return state[dataId];
+    },
+    remove(dataId) {
+        delete state[dataId];
+    },
+    clear() {
+        state = {};
+    },
+};
+addProvider(genericViewportDataSetMetadataProvider.get);
+export default genericViewportDataSetMetadataProvider;

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

@@ -0,0 +1,2 @@
+import type { IImageVolume, OrientationVectors } from '../types';
+export default function getAcquisitionPlaneOrientation(imageVolume: IImageVolume): OrientationVectors;

package/dist/esm/utilities/getAcquisitionPlaneOrientation.js

@@ -0,0 +1,7 @@
+export default function getAcquisitionPlaneOrientation(imageVolume) {
+    const { direction } = imageVolume;
+    return {
+        viewPlaneNormal: direction.slice(6, 9).map((x) => -x),
+        viewUp: direction.slice(3, 6).map((x) => -x),
+    };
+}

package/dist/esm/utilities/getClosestImageId.js

@@ -1,5 +1,6 @@
 import { vec3 } from 'gl-matrix';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 import { coreLog } from './logger';
 import getSpacingInNormalDirection from './getSpacingInNormalDirection';
 import { EPSILON } from '../constants';
@@ -24,7 +25,7 @@ export default function getClosestImageId(imageVolume, worldPos, viewPlaneNormal
     let minDistance = Infinity;
     for (let i = 0; i < imageIds.length; i++) {
         const imageId = imageIds[i];
-        const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+        const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
         if (!imagePlaneModule?.imagePositionPatient) {
             log.warn(`Missing imagePositionPatient for imageId: ${imageId}`);
             continue;

package/dist/esm/utilities/getClosestStackImageIndexForPoint.js

@@ -1,6 +1,7 @@
 import { vec3 } from 'gl-matrix';
 import * as planar from './planar';
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 export default function getClosestStackImageIndexForPoint(point, viewport) {
     const minimalDistance = calculateMinimalDistanceForStackViewport(point, viewport);
     return minimalDistance ? minimalDistance.index : null;
@@ -57,7 +58,7 @@ export function calculateMinimalDistanceForStackViewport(point, viewport) {
     return closestStack.distance === Infinity ? null : closestStack;
 }
 function getPlaneMetadata(imageId) {
-    const targetImagePlane = metaData.get('imagePlaneModule', imageId);
+    const targetImagePlane = metaData.get(MetadataModules.IMAGE_PLANE, imageId);
     if (!targetImagePlane ||
         !(targetImagePlane.rowCosines instanceof Array &&
             targetImagePlane.rowCosines.length === 3) ||

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

@@ -0,0 +1,2 @@
+import type { Point2 } from '../types';
+export declare const getNormalizedAspectRatio: (aspectRatio: Point2) => Point2;

package/dist/esm/utilities/getNormalizedAspectRatio.js

@@ -0,0 +1,12 @@
+import isEqual from './isEqual';
+const EPSILON = 1e10;
+export const getNormalizedAspectRatio = (aspectRatio) => {
+    const [width, height] = aspectRatio;
+    if (isEqual(width, height)) {
+        return [1, 1];
+    }
+    const min = Math.min(width, height);
+    const normalizedW = Math.round((width / min) * EPSILON) / EPSILON;
+    const normalizedH = Math.round((height / min) * EPSILON) / EPSILON;
+    return [normalizedW, normalizedH];
+};

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

@@ -1,13 +1,5 @@
-import { CalibrationTypes } from '../enums';
-export declare function getERMF(instance: any): any;
-export declare function calculateRadiographicPixelSpacing(instance: any): {
-    PixelSpacing: any;
-    type: CalibrationTypes;
-    isProjection: boolean;
-};
-export declare function getPixelSpacingInformation(instance: any): {
-    PixelSpacing: any;
-    type: CalibrationTypes;
-    isProjection: boolean;
-};
-export default getPixelSpacingInformation;
+import { utilities } from '@cornerstonejs/metadata';
+declare const getPixelSpacingInformation: typeof utilities.getPixelSpacingInformation, calculateRadiographicPixelSpacing: typeof utilities.calculateRadiographicPixelSpacing, getERMF: typeof utilities.getERMF;
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, };
+declare const _default: typeof utilities.getPixelSpacingInformation;
+export default _default;

package/dist/esm/utilities/getPixelSpacingInformation.js

@@ -1,93 +1,4 @@
-import { isEqual } from './isEqual';
-import { CalibrationTypes } from '../enums';
-const projectionRadiographSOPClassUIDs = new Set([
-    '1.2.840.10008.5.1.4.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.1.1',
-    '1.2.840.10008.5.1.4.1.1.1.2',
-    '1.2.840.10008.5.1.4.1.1.1.2.1',
-    '1.2.840.10008.5.1.4.1.1.1.3',
-    '1.2.840.10008.5.1.4.1.1.1.3.1',
-    '1.2.840.10008.5.1.4.1.1.12.1',
-    '1.2.840.10008.5.1.4.1.1.12.1.1',
-    '1.2.840.10008.5.1.4.1.1.12.2',
-    '1.2.840.10008.5.1.4.1.1.12.2.1',
-    '1.2.840.10008.5.1.4.1.1.12.3',
-]);
-export function getERMF(instance) {
-    const { PixelSpacing, ImagerPixelSpacing, EstimatedRadiographicMagnificationFactor: ermf, DistanceSourceToDetector: sid, DistanceSourceToPatient: sod, } = instance;
-    if (ermf) {
-        return ermf;
-    }
-    if (sod < sid) {
-        return sid / sod;
-    }
-    if (ImagerPixelSpacing?.[0] > PixelSpacing?.[0]) {
-        return true;
-    }
-}
-export function calculateRadiographicPixelSpacing(instance) {
-    const { PixelSpacing, ImagerPixelSpacing, PixelSpacingCalibrationType } = instance;
-    const isProjection = true;
-    if (PixelSpacing && PixelSpacingCalibrationType === 'GEOMETRY') {
-        if (isEqual(PixelSpacing, ImagerPixelSpacing)) {
-            console.warn('Calibration type is geometry, but pixel spacing and imager pixel spacing identical', PixelSpacing, ImagerPixelSpacing);
-        }
-        return {
-            PixelSpacing,
-            type: CalibrationTypes.ERMF,
-            isProjection,
-        };
-    }
-    if (PixelSpacing && PixelSpacingCalibrationType === 'FIDUCIAL') {
-        return {
-            PixelSpacing,
-            type: CalibrationTypes.CALIBRATED,
-            isProjection,
-        };
-    }
-    if (ImagerPixelSpacing) {
-        const ermf = getERMF(instance);
-        if (ermf > 1) {
-            const correctedPixelSpacing = ImagerPixelSpacing.map((pixelSpacing) => pixelSpacing / ermf);
-            return {
-                PixelSpacing: correctedPixelSpacing,
-                type: CalibrationTypes.ERMF,
-                isProjection,
-            };
-        }
-        if (ermf === true) {
-            return {
-                PixelSpacing,
-                type: CalibrationTypes.ERMF,
-                isProjection,
-            };
-        }
-        if (ermf) {
-            console.error('Illegal ERMF value:', ermf);
-        }
-        return {
-            PixelSpacing: PixelSpacing || ImagerPixelSpacing,
-            type: CalibrationTypes.PROJECTION,
-            isProjection,
-        };
-    }
-    return {
-        PixelSpacing,
-        type: CalibrationTypes.UNKNOWN,
-        isProjection,
-    };
-}
-export function getPixelSpacingInformation(instance) {
-    const { PixelSpacing, SOPClassUID } = instance;
-    const isProjection = projectionRadiographSOPClassUIDs.has(SOPClassUID);
-    if (isProjection) {
-        return calculateRadiographicPixelSpacing(instance);
-    }
-    return {
-        PixelSpacing,
-        type: CalibrationTypes.NOT_APPLICABLE,
-        isProjection: false,
-    };
-}
-export default getPixelSpacingInformation;
+import { utilities } from '@cornerstonejs/metadata';
+const { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, } = utilities;
+export { getPixelSpacingInformation, calculateRadiographicPixelSpacing, getERMF, };
+export default utilities.getPixelSpacingInformation;

package/dist/esm/utilities/getScalingParameters.js

@@ -1,14 +1,15 @@
 import * as metaData from '../metaData';
+import { MetadataModules } from '../enums';
 export default function getScalingParameters(imageId) {
-    const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
+    const modalityLutModule = metaData.get(MetadataModules.MODALITY_LUT, imageId) || {};
+    const generalSeriesModule = metaData.get(MetadataModules.GENERAL_SERIES, imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope || 1,
         rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
-    const scalingModules = metaData.get('scalingModule', imageId) || {};
+    const scalingModules = metaData.get(MetadataModules.SCALING, imageId) || {};
     return {
         ...scalingParameters,
         ...(modality === 'PT' && {

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

@@ -0,0 +1,3 @@
+import { VOILUTFunctionType } from '../enums';
+import type { VOIRange } from '../types';
+export default function getVOIRangeFromWindowLevel(windowWidth: number | number[] | undefined, windowCenter: number | number[] | undefined, voiLUTFunction?: VOILUTFunctionType): VOIRange | undefined;

package/dist/esm/utilities/getVOIRangeFromWindowLevel.js

@@ -0,0 +1,18 @@
+import { VOILUTFunctionType } from '../enums';
+import { toLowHighRange } from './windowLevel';
+export default function getVOIRangeFromWindowLevel(windowWidth, windowCenter, voiLUTFunction = VOILUTFunctionType.LINEAR) {
+    let center;
+    let width;
+    if (typeof windowCenter === 'number' && typeof windowWidth === 'number') {
+        center = windowCenter;
+        width = windowWidth;
+    }
+    else if (Array.isArray(windowCenter) && Array.isArray(windowWidth)) {
+        center = windowCenter[0];
+        width = windowWidth[0];
+    }
+    if (center === undefined || width === undefined) {
+        return;
+    }
+    return toLowHighRange(width, center, voiLUTFunction);
+}

package/dist/esm/utilities/getViewportImageIds.js

@@ -1,4 +1,4 @@
-import { VolumeViewport } from '../RenderingEngine';
+import VolumeViewport from '../RenderingEngine/VolumeViewport';
 import cache from '../cache/cache';
 function getViewportImageIds(viewport) {
     if (viewport instanceof VolumeViewport) {

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

@@ -1,4 +1,2 @@
-import type { IBaseVolumeViewport, IStackViewport } from '../types';
-type Viewport = IStackViewport | IBaseVolumeViewport;
-export default function getViewportsWithImageURI(imageURI: string): Viewport[];
-export {};
+import { type ImageSliceViewport } from './viewportCapabilities';
+export default function getViewportsWithImageURI(imageURI: string): ImageSliceViewport[];

package/dist/esm/utilities/getViewportsWithImageURI.js

@@ -1,9 +1,12 @@
 import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsImageSlices, } from './viewportCapabilities';
 export default function getViewportsWithImageURI(imageURI) {
     const renderingEngines = getRenderingEngines();
     const viewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewportsForRenderingEngine = renderingEngine.getViewports();
+        const viewportsForRenderingEngine = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsImageSlices);
         viewportsForRenderingEngine.forEach((viewport) => {
             if (viewport.hasImageURI(imageURI)) {
                 viewports.push(viewport);

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getViewportsWithVolumeId(volumeId: string): IVolumeViewport[];
+import { type VolumeIdViewport } from './viewportCapabilities';
+declare function getViewportsWithVolumeId(volumeId: string): VolumeIdViewport[];
 export default getViewportsWithVolumeId;

package/dist/esm/utilities/getViewportsWithVolumeId.js

@@ -1,9 +1,12 @@
 import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeId, } from './viewportCapabilities';
 function getViewportsWithVolumeId(volumeId) {
     const renderingEngines = getRenderingEngines();
     const targetViewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeId);
         const filteredViewports = viewports.filter((vp) => vp.hasVolumeId(volumeId));
         targetViewports.push(...filteredViewports);
     });

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getViewportsWithVolumeURI(volumeURI: string, renderingEngineId?: string): IVolumeViewport[];
+import { type VolumeURIViewport } from './viewportCapabilities';
+declare function getViewportsWithVolumeURI(volumeURI: string, renderingEngineId?: string): VolumeURIViewport[];
 export default getViewportsWithVolumeURI;

package/dist/esm/utilities/getViewportsWithVolumeURI.js

@@ -1,11 +1,14 @@
 import { getRenderingEngines, getRenderingEngine, } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeURI, } from './viewportCapabilities';
 function getViewportsWithVolumeURI(volumeURI, renderingEngineId) {
     const renderingEngines = renderingEngineId
         ? [getRenderingEngine(renderingEngineId)]
         : getRenderingEngines();
     const targetViewports = [];
     renderingEngines.forEach((renderingEngine) => {
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeURI);
         const filteredViewports = viewports.filter((vp) => vp.hasVolumeURI(volumeURI));
         targetViewports.push(...filteredViewports);
     });

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

@@ -0,0 +1,6 @@
+import type { Point3 } from '../types';
+export default function getVolumeViewReferenceId(args: {
+    sliceIndex: number;
+    viewPlaneNormal: Point3;
+    volumeId: string;
+}): string;

package/dist/esm/utilities/getVolumeViewReferenceId.js

@@ -0,0 +1,6 @@
+export default function getVolumeViewReferenceId(args) {
+    const { sliceIndex, viewPlaneNormal, volumeId } = args;
+    const querySeparator = volumeId.includes('?') ? '&' : '?';
+    const formattedNormal = viewPlaneNormal.map((value) => value.toFixed(3));
+    return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${formattedNormal.join(',')}`;
+}

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

@@ -5,7 +5,7 @@ declare function getVolumeViewportScrollInfo(viewport: IVolumeViewport, volumeId
     sliceRangeInfo: {
         sliceRange: import("../types").ActorSliceRange;
         spacingInNormalDirection: number;
-        camera: import("../types").ICamera;
+        camera: import("../types").ICamera<number>;
     };
 };
 export default getVolumeViewportScrollInfo;

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

@@ -1,3 +1,3 @@
-import type { IVolumeViewport } from '../types';
-declare function getVolumeViewportsContainingSameVolumes(targetViewport: IVolumeViewport, renderingEngineId?: string): IVolumeViewport[];
+import { type VolumeActorViewport } from './viewportCapabilities';
+declare function getVolumeViewportsContainingSameVolumes(targetViewport: VolumeActorViewport, renderingEngineId?: string): VolumeActorViewport[];
 export default getVolumeViewportsContainingSameVolumes;

package/dist/esm/utilities/getVolumeViewportsContainingSameVolumes.js

@@ -1,4 +1,5 @@
 import { getRenderingEngines, getRenderingEngine, } from '../RenderingEngine/getRenderingEngine';
+import { viewportSupportsVolumeActors, } from './viewportCapabilities';
 function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngineId) {
     let renderingEngines;
     if (renderingEngineId) {
@@ -10,7 +11,9 @@ function getVolumeViewportsContainingSameVolumes(targetViewport, renderingEngine
     const sameVolumesViewports = [];
     renderingEngines.forEach((renderingEngine) => {
         const targetActors = targetViewport.getActors();
-        const viewports = renderingEngine.getVolumeViewports();
+        const viewports = renderingEngine
+            .getViewports()
+            .filter(viewportSupportsVolumeActors);
         for (const vp of viewports) {
             const vpActors = vp.getActors();
             if (vpActors.length !== targetActors.length) {

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

@@ -0,0 +1 @@
+export default function hasOwn<T extends object, K extends PropertyKey>(object: T, key: K): object is T & Record<K, unknown>;

package/dist/esm/utilities/hasOwn.js

@@ -0,0 +1,3 @@
+export default function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}

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

@@ -1 +1,3 @@
-export default function imageIdToURI(imageId: string): string;
+import { utilities } from '@cornerstonejs/metadata';
+declare const _default: typeof utilities.imageIdToURI;
+export default _default;

package/dist/esm/utilities/imageIdToURI.js

@@ -1,4 +1,2 @@
-export default function imageIdToURI(imageId) {
-    const colonIndex = imageId.indexOf(':');
-    return imageId.substring(colonIndex + 1);
-}
+import { utilities } from '@cornerstonejs/metadata';
+export default utilities.imageIdToURI;