@cornerstonejs/tools 4.22.13 → 5.0.0

package/dist/esm/utilities/segmentation/InterpolationManager/InterpolationManager.js

@@ -1,3 +1,4 @@
+var _a;
 import { utilities as csUtils } from '@cornerstonejs/core';
 import { state as annotationState } from '../../../stateManagement/annotation';
 import getInterpolationDataCollection from '../../contours/interpolation/getInterpolationDataCollection';
@@ -11,8 +12,7 @@ const ChangeTypesForInterpolation = [
     ChangeTypes.HandlesUpdated,
     ChangeTypes.InterpolationUpdated,
 ];
-export default class InterpolationManager {
-    static { this.toolNames = []; }
+class InterpolationManager {
     static addTool(toolName) {
         if (!this.toolNames.includes(toolName)) {
             this.toolNames.push(toolName);
@@ -25,7 +25,7 @@ export default class InterpolationManager {
     }
     static acceptAutoGenerated(annotationGroupSelector, selector = {}) {
         const { toolNames, segmentationId, segmentIndex, sliceIndex } = selector;
-        for (const toolName of toolNames || InterpolationManager.toolNames) {
+        for (const toolName of toolNames || _a.toolNames) {
             const annotations = annotationState.getAnnotations(toolName, annotationGroupSelector);
             if (!annotations?.length) {
                 continue;
@@ -55,124 +55,127 @@ export default class InterpolationManager {
             }
         }
     }
-    static { this.handleAnnotationCompleted = (evt) => {
-        const annotation = evt.detail.annotation;
-        if (!annotation?.metadata) {
-            return;
-        }
-        const { toolName, originalToolName } = annotation.metadata;
-        if (!this.toolNames.includes(toolName) &&
-            !this.toolNames.includes(originalToolName)) {
-            return;
-        }
-        const viewport = getViewportForAnnotation(annotation);
-        if (!viewport) {
-            console.warn('Unable to find viewport for', annotation);
-            return;
-        }
-        const sliceData = getSliceData(viewport);
-        const viewportData = {
-            viewport,
-            sliceData,
-            annotation,
-            interpolationUID: annotation.interpolationUID,
-        };
-        const hasInterpolationUID = !!annotation.interpolationUID;
-        annotation.autoGenerated = false;
-        if (hasInterpolationUID) {
-            deleteRelatedAnnotations(viewportData);
-            interpolate(viewportData);
-            return;
-        }
-        const filterData = [
-            {
-                key: 'segmentIndex',
-                value: annotation.data.segmentation.segmentIndex,
-                parentKey: (annotation) => annotation.data.segmentation,
-            },
-            {
-                key: 'viewPlaneNormal',
-                value: annotation.metadata.viewPlaneNormal,
-                parentKey: (annotation) => annotation.metadata,
-            },
-            {
-                key: 'viewUp',
-                value: annotation.metadata.viewUp,
-                parentKey: (annotation) => annotation.metadata,
-            },
-        ];
-        let interpolationAnnotations = getInterpolationDataCollection(viewportData, filterData);
-        const { sliceIndex } = annotation.metadata;
-        const skipUIDs = new Set();
-        interpolationAnnotations.forEach((interpolationAnnotation) => {
-            if (interpolationAnnotation.interpolationCompleted ||
-                interpolationAnnotation.metadata.sliceIndex === sliceIndex) {
-                const { interpolationUID } = interpolationAnnotation;
-                skipUIDs.add(interpolationUID);
-            }
-        });
-        interpolationAnnotations = interpolationAnnotations.filter((interpolationAnnotation) => !skipUIDs.has(interpolationAnnotation.interpolationUID));
-        annotation.interpolationUID =
-            interpolationAnnotations[0]?.interpolationUID || uuidv4();
-        viewportData.interpolationUID = annotation.interpolationUID;
-        interpolate(viewportData);
-    }; }
-    static { this.handleAnnotationUpdate = (evt) => {
-        const annotation = evt.detail.annotation;
-        const { changeType = ChangeTypes.HandlesUpdated } = evt.detail;
-        if (!annotation?.metadata) {
-            return;
-        }
-        const { toolName, originalToolName } = annotation.metadata;
-        if ((!this.toolNames.includes(toolName) &&
-            !this.toolNames.includes(originalToolName)) ||
-            !ChangeTypesForInterpolation.includes(changeType)) {
-            return;
-        }
-        const viewport = getViewportForAnnotation(annotation);
-        if (!viewport) {
-            console.warn('Unable to find matching viewport for annotation interpolation', annotation);
-            return;
-        }
-        if (annotation.autoGenerated) {
-            addContourSegmentationAnnotation(annotation);
-            annotation.autoGenerated = false;
-        }
-        const sliceData = getSliceData(viewport);
-        const viewportData = {
-            viewport,
-            sliceData,
-            annotation,
-            interpolationUID: annotation.interpolationUID,
-            isInterpolationUpdate: changeType === ChangeTypes.InterpolationUpdated,
-        };
+}
+_a = InterpolationManager;
+InterpolationManager.toolNames = [];
+InterpolationManager.handleAnnotationCompleted = (evt) => {
+    const annotation = evt.detail.annotation;
+    if (!annotation?.metadata) {
+        return;
+    }
+    const { toolName, originalToolName } = annotation.metadata;
+    if (!_a.toolNames.includes(toolName) &&
+        !_a.toolNames.includes(originalToolName)) {
+        return;
+    }
+    const viewport = getViewportForAnnotation(annotation);
+    if (!viewport) {
+        console.warn('Unable to find viewport for', annotation);
+        return;
+    }
+    const sliceData = getSliceData(viewport);
+    const viewportData = {
+        viewport,
+        sliceData,
+        annotation,
+        interpolationUID: annotation.interpolationUID,
+    };
+    const hasInterpolationUID = !!annotation.interpolationUID;
+    annotation.autoGenerated = false;
+    if (hasInterpolationUID) {
+        deleteRelatedAnnotations(viewportData);
         interpolate(viewportData);
-    }; }
-    static { this.handleAnnotationDelete = (evt) => {
-        const annotation = evt.detail.annotation;
-        if (!annotation?.metadata) {
-            return;
-        }
-        const { toolName } = annotation.metadata;
-        if (!this.toolNames.includes(toolName) || annotation.autoGenerated) {
-            return;
-        }
-        const viewport = getViewportForAnnotation(annotation);
-        if (!viewport) {
-            console.warn("No viewport, can't delete interpolated results", annotation);
-            return;
+        return;
+    }
+    const filterData = [
+        {
+            key: 'segmentIndex',
+            value: annotation.data.segmentation.segmentIndex,
+            parentKey: (annotation) => annotation.data.segmentation,
+        },
+        {
+            key: 'viewPlaneNormal',
+            value: annotation.metadata.viewPlaneNormal,
+            parentKey: (annotation) => annotation.metadata,
+        },
+        {
+            key: 'viewUp',
+            value: annotation.metadata.viewUp,
+            parentKey: (annotation) => annotation.metadata,
+        },
+    ];
+    let interpolationAnnotations = getInterpolationDataCollection(viewportData, filterData);
+    const { sliceIndex } = annotation.metadata;
+    const skipUIDs = new Set();
+    interpolationAnnotations.forEach((interpolationAnnotation) => {
+        if (interpolationAnnotation.interpolationCompleted ||
+            interpolationAnnotation.metadata.sliceIndex === sliceIndex) {
+            const { interpolationUID } = interpolationAnnotation;
+            skipUIDs.add(interpolationUID);
         }
-        const sliceData = getSliceData(viewport);
-        const viewportData = {
-            viewport,
-            sliceData,
-            annotation,
-            interpolationUID: annotation.interpolationUID,
-        };
+    });
+    interpolationAnnotations = interpolationAnnotations.filter((interpolationAnnotation) => !skipUIDs.has(interpolationAnnotation.interpolationUID));
+    annotation.interpolationUID =
+        interpolationAnnotations[0]?.interpolationUID || uuidv4();
+    viewportData.interpolationUID = annotation.interpolationUID;
+    interpolate(viewportData);
+};
+InterpolationManager.handleAnnotationUpdate = (evt) => {
+    const annotation = evt.detail.annotation;
+    const { changeType = ChangeTypes.HandlesUpdated } = evt.detail;
+    if (!annotation?.metadata) {
+        return;
+    }
+    const { toolName, originalToolName } = annotation.metadata;
+    if ((!_a.toolNames.includes(toolName) &&
+        !_a.toolNames.includes(originalToolName)) ||
+        !ChangeTypesForInterpolation.includes(changeType)) {
+        return;
+    }
+    const viewport = getViewportForAnnotation(annotation);
+    if (!viewport) {
+        console.warn('Unable to find matching viewport for annotation interpolation', annotation);
+        return;
+    }
+    if (annotation.autoGenerated) {
+        addContourSegmentationAnnotation(annotation);
         annotation.autoGenerated = false;
-        deleteRelatedAnnotations(viewportData);
-    }; }
-}
+    }
+    const sliceData = getSliceData(viewport);
+    const viewportData = {
+        viewport,
+        sliceData,
+        annotation,
+        interpolationUID: annotation.interpolationUID,
+        isInterpolationUpdate: changeType === ChangeTypes.InterpolationUpdated,
+    };
+    interpolate(viewportData);
+};
+InterpolationManager.handleAnnotationDelete = (evt) => {
+    const annotation = evt.detail.annotation;
+    if (!annotation?.metadata) {
+        return;
+    }
+    const { toolName } = annotation.metadata;
+    if (!_a.toolNames.includes(toolName) || annotation.autoGenerated) {
+        return;
+    }
+    const viewport = getViewportForAnnotation(annotation);
+    if (!viewport) {
+        console.warn("No viewport, can't delete interpolated results", annotation);
+        return;
+    }
+    const sliceData = getSliceData(viewport);
+    const viewportData = {
+        viewport,
+        sliceData,
+        annotation,
+        interpolationUID: annotation.interpolationUID,
+    };
+    annotation.autoGenerated = false;
+    deleteRelatedAnnotations(viewportData);
+};
+export default InterpolationManager;
 function getSliceData(viewport) {
     const sliceData = {
         numberOfSlices: viewport.getNumberOfSlices(),

package/dist/esm/utilities/segmentation/SegmentStatsCalculator.js

@@ -1,8 +1,5 @@
 import { InstanceVolumetricCalculator } from './VolumetricCalculator';
-export default class SegmentStatsCalculator {
-    static { this.calculators = new Map(); }
-    static { this.indices = []; }
-    static { this.mode = 'collective'; }
+class SegmentStatsCalculator {
     static statsInit(options) {
         const { storePointData, indices, mode } = options;
         this.mode = mode;
@@ -42,3 +39,7 @@ export default class SegmentStatsCalculator {
         return calculator.getStatistics(options);
     }
 }
+SegmentStatsCalculator.calculators = new Map();
+SegmentStatsCalculator.indices = [];
+SegmentStatsCalculator.mode = 'collective';
+export default SegmentStatsCalculator;

package/dist/esm/utilities/segmentation/VolumetricCalculator.js

@@ -59,7 +59,6 @@ function volumetricGetStatistics(state, stats, options) {
     return stats;
 }
 export class VolumetricCalculator extends BasicStatsCalculator {
-    static { this.volumetricState = createVolumetricState(); }
     static statsInit(options) {
         super.statsInit(options);
         this.volumetricState = createVolumetricState();
@@ -79,6 +78,7 @@ export class VolumetricCalculator extends BasicStatsCalculator {
         return volumetricGetStatistics(this.volumetricState, stats, optionsWithUnit);
     }
 }
+VolumetricCalculator.volumetricState = createVolumetricState();
 export class InstanceVolumetricCalculator extends InstanceBasicStatsCalculator {
     constructor(options) {
         super(options);

package/dist/esm/utilities/segmentation/createLabelmapVolumeForViewport.js

@@ -15,7 +15,7 @@ export default async function createLabelmapVolumeForViewport(input) {
         segmentationId = `${uid}-based-segmentation-${options?.volumeId ?? csUtils.uuidv4().slice(0, 8)}`;
     }
     if (options) {
-        const properties = structuredClone(options);
+        const properties = csUtils.deepClone(options);
         await volumeLoader.createLocalVolume(segmentationId, properties);
     }
     else {

package/dist/esm/utilities/segmentation/getReferenceVolumeForSegmentation.js

@@ -17,7 +17,7 @@ export function getReferenceVolumeForSegmentation(segmentationId) {
         }
         referenceImageIds = imageIds.map((imageId) => cache.getImage(imageId).referencedImageId);
     }
-    else if ('volumeId' in labelmap) {
+    else if (labelmap.volumeId) {
         const { volumeId, referencedVolumeId } = labelmap;
         if (referencedVolumeId) {
             const refVolume = cache.getVolume(referencedVolumeId);

package/dist/esm/utilities/segmentation/getReferenceVolumeForSegmentationVolume.js

@@ -11,9 +11,18 @@ export function getReferenceVolumeForSegmentationVolume(segmentationVolumeId) {
     }
     else {
         const imageIds = segmentationVolume.imageIds;
-        const image = cache.getImage(imageIds[0]);
+        const segmentationImageId = imageIds?.[0];
+        if (!segmentationImageId) {
+            return null;
+        }
+        const image = cache.getImage(segmentationImageId);
+        if (!image) {
+            return null;
+        }
         const referencedImageId = image.referencedImageId;
-        let volumeInfo = cache.getVolumeContainingImageId(referencedImageId);
+        let volumeInfo = referencedImageId
+            ? cache.getVolumeContainingImageId(referencedImageId)
+            : undefined;
         if (!volumeInfo?.volume) {
             volumeInfo = cache.getVolumeContainingImageId(image.imageId);
         }

package/dist/esm/utilities/segmentation/getSegmentIndexAtLabelmapBorder.js

@@ -1,29 +1,41 @@
 import { BaseVolumeViewport, cache, utilities } from '@cornerstonejs/core';
 import { getSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers';
+import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { getLabelmaps, getOrCreateLabelmapVolume, getSegmentIndexForLabelValue, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
-    const labelmapData = segmentation.representationData.Labelmap;
-    if (viewport instanceof BaseVolumeViewport) {
-        const { volumeId } = labelmapData;
-        const segmentationVolume = cache.getVolume(volumeId);
-        if (!segmentationVolume) {
-            return;
+    const viewportRenderMode = viewport
+        ? getViewportLabelmapRenderMode(viewport)
+        : 'unsupported';
+    if (viewportRenderMode === 'volume' ||
+        viewport instanceof BaseVolumeViewport) {
+        for (const layer of getLabelmaps(segmentation)) {
+            const segmentationVolume = getOrCreateLabelmapVolume(layer);
+            if (!segmentationVolume) {
+                continue;
+            }
+            const voxelManager = segmentationVolume.voxelManager;
+            const imageData = segmentationVolume.imageData;
+            const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+            const labelValue = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
+            const canvasPoint = viewport.worldToCanvas(worldPoint);
+            const onEdge = isSegmentOnEdgeCanvas(canvasPoint, labelValue, viewport, imageData, searchRadius);
+            if (onEdge && labelValue) {
+                return getSegmentIndexForLabelValue(segmentation, layer.labelmapId, labelValue);
+            }
         }
-        const voxelManager = segmentationVolume.voxelManager;
-        const imageData = segmentationVolume.imageData;
-        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
-        const segmentIndex = voxelManager.getAtIJK(indexIJK[0], indexIJK[1], indexIJK[2]);
-        const canvasPoint = viewport.worldToCanvas(worldPoint);
-        const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
-        return onEdge ? segmentIndex : undefined;
+        return;
     }
     const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+    if (!segmentationImageId) {
+        return;
+    }
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;
     }
-    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentationId);
+    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentationId, segmentationImageId);
     const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
     const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
     const dimensions = imageData.getDimensions();
@@ -32,9 +44,16 @@ export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { vi
             dimensions,
             scalarData: imageData.getPointData().getScalars().getData(),
         }));
-    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
-    const onEdge = isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex);
-    return onEdge ? segmentIndex : undefined;
+    const labelValue = voxelManager.getAtIJKPoint(indexIJK);
+    const onEdge = isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, labelValue);
+    if (!onEdge || !labelValue) {
+        return;
+    }
+    const layer = getLabelmaps(segmentation).find((candidateLayer) => candidateLayer.imageIds?.includes(segmentationImageId));
+    if (!layer) {
+        return labelValue;
+    }
+    return getSegmentIndexForLabelValue(segmentation, layer.labelmapId, labelValue);
 }
 function isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius = 1) {
     const neighborRange = Array.from({ length: 2 * searchRadius + 1 }, (_, i) => i - searchRadius);

package/dist/esm/utilities/segmentation/getSegmentIndexAtWorldPoint.js

@@ -4,6 +4,8 @@ import { getSegmentation, getCurrentLabelmapImageIdsForViewport, } from '../../s
 import { getAnnotation } from '../../stateManagement';
 import { isPointInsidePolyline3D } from '../math/polyline';
 import { getLabelmapActorEntry } from '../../stateManagement/segmentation/helpers/getSegmentationActor';
+import getViewportLabelmapRenderMode from '../../stateManagement/segmentation/helpers/getViewportLabelmapRenderMode';
+import { getLabelmaps, getOrCreateLabelmapVolume, getSegmentIndexForLabelValue, } from '../../stateManagement/segmentation/helpers/labelmapSegmentationState';
 export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
@@ -21,37 +23,52 @@ export function getSegmentIndexAtWorldPoint(segmentationId, worldPoint, options
     }
 }
 export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { viewport }) {
-    const labelmapData = segmentation.representationData.Labelmap;
-    if (viewport instanceof BaseVolumeViewport) {
-        const { volumeId } = labelmapData;
-        const segmentationVolume = cache.getVolume(volumeId);
-        if (!segmentationVolume) {
-            return;
+    const viewportRenderMode = viewport
+        ? getViewportLabelmapRenderMode(viewport)
+        : 'unsupported';
+    if (viewportRenderMode === 'volume' ||
+        viewport instanceof BaseVolumeViewport) {
+        for (const layer of getLabelmaps(segmentation)) {
+            const segmentationVolume = getOrCreateLabelmapVolume(layer);
+            if (!segmentationVolume) {
+                continue;
+            }
+            const labelValue = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
+            if (!labelValue) {
+                continue;
+            }
+            return getSegmentIndexForLabelValue(segmentation, layer.labelmapId, labelValue);
         }
-        const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
-        return segmentIndex;
+        return;
     }
     const segmentationImageIds = getCurrentLabelmapImageIdsForViewport(viewport.id, segmentation.segmentationId);
-    if (segmentationImageIds.length > 1) {
-        console.warn('Segment selection for labelmaps with multiple imageIds in stack viewports is not supported yet.');
+    if (!segmentationImageIds?.length) {
         return;
     }
-    const segmentationImageId = segmentationImageIds[0];
-    const image = cache.getImage(segmentationImageId);
-    if (!image) {
-        return;
+    for (const segmentationImageId of segmentationImageIds) {
+        const image = cache.getImage(segmentationImageId);
+        if (!image) {
+            continue;
+        }
+        const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentation.segmentationId, segmentationImageId);
+        const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
+        const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
+        const dimensions = imageData.getDimensions();
+        const voxelManager = (imageData.voxelManager ||
+            utilities.VoxelManager.createScalarVolumeVoxelManager({
+                dimensions,
+                scalarData: imageData.getPointData().getScalars().getData(),
+            }));
+        const labelValue = voxelManager.getAtIJKPoint(indexIJK);
+        if (!labelValue) {
+            continue;
+        }
+        const layer = getLabelmaps(segmentation).find((candidateLayer) => candidateLayer.imageIds?.includes(segmentationImageId));
+        if (!layer) {
+            return labelValue;
+        }
+        return getSegmentIndexForLabelValue(segmentation, layer.labelmapId, labelValue);
     }
-    const segmentationActorEntry = getLabelmapActorEntry(viewport.id, segmentation.segmentationId);
-    const imageData = segmentationActorEntry?.actor.getMapper().getInputData();
-    const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
-    const dimensions = imageData.getDimensions();
-    const voxelManager = (imageData.voxelManager ||
-        utilities.VoxelManager.createScalarVolumeVoxelManager({
-            dimensions,
-            scalarData: imageData.getPointData().getScalars().getData(),
-        }));
-    const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
-    return segmentIndex;
 }
 export function getSegmentIndexAtWorldForContour(segmentation, worldPoint, { viewport }) {
     const contourData = segmentation.representationData.Contour;

package/dist/esm/utilities/segmentation/getUniqueSegmentIndices.js

@@ -13,7 +13,7 @@ function getUniqueSegmentIndices(segmentationId) {
     }
     let indices;
     if (segmentation.representationData.Labelmap) {
-        indices = handleLabelmapSegmentation(segmentation, segmentationId);
+        indices = handleLabelmapSegmentation(segmentation);
     }
     else if (segmentation.representationData.Contour) {
         indices = handleContourSegmentation(segmentation);
@@ -27,38 +27,11 @@ function getUniqueSegmentIndices(segmentationId) {
     setCachedSegmentIndices(segmentationId, indices);
     return indices;
 }
-function handleLabelmapSegmentation(segmentation, segmentationId) {
-    const labelmapData = segmentation.representationData[SegmentationRepresentations.Labelmap];
-    const keySet = new Set();
-    if (labelmapData.imageIds) {
-        addImageSegmentIndices(keySet, labelmapData.imageIds);
-    }
-    else {
-        addVolumeSegmentIndices(keySet, segmentationId);
-    }
-    return Array.from(keySet)
+function handleLabelmapSegmentation(segmentation) {
+    return Object.keys(segmentation.segments)
         .map(Number)
         .sort((a, b) => a - b);
 }
-function addVolumeSegmentIndices(keySet, segmentationId) {
-    const volume = cache.getVolume(segmentationId);
-    volume.voxelManager.forEach(({ value }) => {
-        if (value !== 0) {
-            keySet.add(value);
-        }
-    });
-}
-function addImageSegmentIndices(keySet, imageIds) {
-    imageIds.forEach((segmentationImageId) => {
-        const image = cache.getImage(segmentationImageId);
-        const scalarData = image.voxelManager.getScalarData();
-        scalarData.forEach((segmentIndex) => {
-            if (segmentIndex !== 0) {
-                keySet.add(segmentIndex);
-            }
-        });
-    });
-}
 function handleContourSegmentation(segmentation) {
     const { annotationUIDsMap, geometryIds } = segmentation.representationData.Contour || {};
     if (!geometryIds) {

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

@@ -28,6 +28,7 @@ import * as validateLabelmap from './validateLabelmap';
 import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
 import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
 import { getReferenceVolumeForSegmentationVolume } from './getReferenceVolumeForSegmentationVolume';
+import { getReferenceVolumeForSegmentation } from './getReferenceVolumeForSegmentation';
 import { getSegmentLargestBidirectional } from './getSegmentLargestBidirectional';
 import { computeMetabolicStats } from './computeMetabolicStats';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, computeMetabolicStats, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getReferenceVolumeForSegmentation, getSegmentLargestBidirectional, computeMetabolicStats, };

package/dist/esm/utilities/segmentation/index.js

@@ -28,6 +28,7 @@ import * as validateLabelmap from './validateLabelmap';
 import { computeStackLabelmapFromVolume } from '../../stateManagement/segmentation/helpers/computeStackLabelmapFromVolume';
 import { computeVolumeLabelmapFromStack } from '../../stateManagement/segmentation/helpers/computeVolumeLabelmapFromStack';
 import { getReferenceVolumeForSegmentationVolume } from './getReferenceVolumeForSegmentationVolume';
+import { getReferenceVolumeForSegmentation } from './getReferenceVolumeForSegmentation';
 import { getSegmentLargestBidirectional } from './getSegmentLargestBidirectional';
 import { computeMetabolicStats } from './computeMetabolicStats';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getSegmentLargestBidirectional, computeMetabolicStats, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, SegmentStatsCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, growCut, LabelmapMemo, IslandRemoval, getOrCreateSegmentationVolume, getOrCreateImageVolume, getStatistics, validateLabelmap, computeStackLabelmapFromVolume, computeVolumeLabelmapFromStack, getReferenceVolumeForSegmentationVolume, getReferenceVolumeForSegmentation, getSegmentLargestBidirectional, computeMetabolicStats, };

package/dist/esm/utilities/segmentation/utilsForWorker.js

@@ -29,8 +29,8 @@ export const getSegmentationDataForWorker = (segmentationId, segmentIndices) =>
         volumeId: segVolumeId,
         imageIds: segImageIds,
     };
-    let reconstructableVolume = false;
-    if (segImageIds) {
+    let reconstructableVolume = Boolean(segVolumeId);
+    if (!reconstructableVolume && segImageIds) {
         const refImageIds = segImageIds.map((imageId) => {
             const image = cache.getImage(imageId);
             return image.referencedImageId;

package/dist/esm/utilities/segmentation/validateLabelmap.js

@@ -1,6 +1,6 @@
 import { cache } from '@cornerstonejs/core';
 function validateRepresentationData(segmentationRepresentationData) {
-    if ('volumeId' in segmentationRepresentationData) {
+    if (segmentationRepresentationData.volumeId) {
         segmentationRepresentationData =
             segmentationRepresentationData;
         const cachedVolume = cache.getVolume(segmentationRepresentationData.volumeId);

package/dist/esm/utilities/stackPrefetch/stackPrefetch.js

@@ -58,7 +58,6 @@ function prefetch(element) {
     let nextImageIdIndex;
     const preventCache = false;
     function doneCallback(imageId) {
-        console.log('prefetch done: %s', imageId);
         const imageIdIndex = stack.imageIds.indexOf(imageId);
         removeFromList(imageIdIndex);
         if (stackPrefetch.indicesToRequest.length === 0) {

package/dist/esm/utilities/touch/index.js

@@ -1,3 +1,4 @@
+import { utilities } from '@cornerstonejs/core';
 function getDeltaPoints(currentPoints, lastPoints) {
     const curr = getMeanPoints(currentPoints);
     const last = getMeanPoints(lastPoints);
@@ -32,10 +33,10 @@ function getDeltaDistanceBetweenIPoints(currentPoints, lastPoints) {
     return deltaDistance;
 }
 function copyPointsList(points) {
-    return JSON.parse(JSON.stringify(points));
+    return utilities.deepClone(points);
 }
 function copyPoints(points) {
-    return JSON.parse(JSON.stringify(points));
+    return utilities.deepClone(points);
 }
 function getMeanPoints(points) {
     return points.reduce((prev, curr) => {

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

@@ -0,0 +1,16 @@
+import type { Types } from '@cornerstonejs/core';
+export type ImageSliceViewport = Types.IViewport & {
+    getCurrentImageId(): string | undefined;
+    getCurrentImageIdIndex(): number;
+    getImageIds(): string[];
+    hasImageURI(imageURI: string): boolean;
+};
+export type StackCompatibilityViewport = ImageSliceViewport & {
+    setStack(imageIds: string[], currentImageIdIndex?: number): Promise<string> | string;
+};
+export type StackCalibrationViewport = ImageSliceViewport & {
+    calibrateSpacing(imageId: string): void;
+};
+export declare function viewportSupportsImageSlices(viewport: unknown): viewport is ImageSliceViewport;
+export declare function viewportSupportsStackCompatibility(viewport: unknown): viewport is StackCompatibilityViewport;
+export declare function viewportSupportsStackCalibration(viewport: unknown): viewport is StackCalibrationViewport;