@cornerstonejs/tools 3.8.3 → 3.8.5

package/dist/esm/enums/WorkerTypes.d.ts

@@ -6,6 +6,7 @@ declare enum ChangeTypes {
     SURFACE_CLIPPING = "Clipping Surfaces",
     COMPUTE_STATISTICS = "Computing Statistics",
     INTERPOLATE_LABELMAP = "Interpolating Labelmap",
-    COMPUTE_LARGEST_BIDIRECTIONAL = "Computing Largest Bidirectional"
+    COMPUTE_LARGEST_BIDIRECTIONAL = "Computing Largest Bidirectional",
+    GENERATE_CONTOUR_SETS = "Generating Contour Sets"
 }
 export default ChangeTypes;

package/dist/esm/enums/WorkerTypes.js

@@ -8,5 +8,6 @@ var ChangeTypes;
     ChangeTypes["COMPUTE_STATISTICS"] = "Computing Statistics";
     ChangeTypes["INTERPOLATE_LABELMAP"] = "Interpolating Labelmap";
     ChangeTypes["COMPUTE_LARGEST_BIDIRECTIONAL"] = "Computing Largest Bidirectional";
+    ChangeTypes["GENERATE_CONTOUR_SETS"] = "Generating Contour Sets";
 })(ChangeTypes || (ChangeTypes = {}));
 export default ChangeTypes;

package/dist/esm/stateManagement/segmentation/getViewportSegmentations.d.ts

@@ -1,3 +1,4 @@
 import type { SegmentationRepresentations } from '../../enums';
-import type { Segmentation } from '../../types';
+import type { Segmentation, SegmentationRepresentation } from '../../types';
 export declare function getViewportSegmentations(viewportId: string, type?: SegmentationRepresentations): Segmentation[];
+export declare function getViewportSegmentationRepresentations(viewportId: string): SegmentationRepresentation[];

package/dist/esm/stateManagement/segmentation/getViewportSegmentations.js

@@ -1,9 +1,7 @@
 import { getSegmentation } from './getSegmentation';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
 export function getViewportSegmentations(viewportId, type) {
-    const segmentationStateManager = defaultSegmentationStateManager;
-    const state = segmentationStateManager.getState();
-    const viewportRepresentations = state.viewportSegRepresentations[viewportId];
+    const viewportRepresentations = getViewportSegmentationRepresentations(viewportId);
     const segmentations = viewportRepresentations.map((representation) => {
         if (type && representation.type === type) {
             return getSegmentation(representation.segmentationId);
@@ -13,3 +11,9 @@ export function getViewportSegmentations(viewportId, type) {
     const filteredSegmentations = segmentations.filter((segmentation) => segmentation !== undefined);
     return filteredSegmentations;
 }
+export function getViewportSegmentationRepresentations(viewportId) {
+    const segmentationStateManager = defaultSegmentationStateManager;
+    const state = segmentationStateManager.getState();
+    const viewportRepresentations = state.viewportSegRepresentations[viewportId];
+    return viewportRepresentations;
+}

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.d.ts

@@ -3,5 +3,4 @@ export declare function getLabelmapActorUID(viewportId: string, segmentationId:
 export declare function getLabelmapActorEntries(viewportId: string, segmentationId: string): Types.ActorEntry[];
 export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string): Types.ActorEntry;
 export declare function getSurfaceActorEntry(viewportId: string, segmentationId: string, segmentIndex?: number | string): Types.ActorEntry;
-export declare function getSurfaceActorUID(viewportId: string, segmentationId: string, segmentIndex?: number | string): string | undefined;
 export declare function getSurfaceRepresentationUID(segmentationId: string, segmentIndex?: number | string): string;

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.js

@@ -40,11 +40,6 @@ export function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID ===
         getSurfaceRepresentationUID(segmentationId, segmentIndex));
 }
-export function getSurfaceActorUID(viewportId, segmentationId, segmentIndex) {
-    const segIndex = segmentIndex ? segmentIndex.toString() : '';
-    const actorEntry = getSurfaceActorEntry(viewportId, segmentationId, segIndex);
-    return actorEntry?.uid;
-}
 export function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
     return `${segmentationId}-${SegmentationRepresentations.Surface}-${segmentIndex}`;
 }

package/dist/esm/stateManagement/segmentation/helpers/index.d.ts

@@ -1,3 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID } from './getSegmentationActor';
-export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };
+import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, };

package/dist/esm/stateManagement/segmentation/helpers/index.js

@@ -1,3 +1,3 @@
 import validateSegmentationInput from './validateSegmentationInput';
-import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, } from './getSegmentationActor';
-export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, getSurfaceActorUID, };
+import { getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, } from './getSegmentationActor';
+export { validateSegmentationInput, getLabelmapActorEntries, getLabelmapActorEntry, getSurfaceActorEntry, getLabelmapActorUID, };

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -3,9 +3,7 @@ import { triggerAnnotationRenderForViewportIds } from '../../utilities/triggerAn
 import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { addColorLUT } from './addColorLUT';
-import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
-import { getColorLUT } from './getColorLUT';
 function internalAddSegmentationRepresentation(viewportId, representationInput) {
     const { segmentationId, config } = representationInput;
     const renderingConfig = {

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -7,11 +7,11 @@ import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
-import { getViewportSegmentations } from './getViewportSegmentations';
+import { getViewportSegmentations, getViewportSegmentationRepresentations } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
 import { getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
 import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId } from './getSegmentationRepresentation';
 declare function destroy(): void;
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

package/dist/esm/stateManagement/segmentation/segmentationState.js

@@ -7,7 +7,7 @@ import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
 import { getNextColorLUTIndex } from './getNextColorLUTIndex';
 import { removeColorLUT } from './removeColorLUT';
-import { getViewportSegmentations } from './getViewportSegmentations';
+import { getViewportSegmentations, getViewportSegmentationRepresentations, } from './getViewportSegmentations';
 import { getViewportIdsWithSegmentation } from './getViewportIdsWithSegmentation';
 import { getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
@@ -17,4 +17,4 @@ import { defaultSegmentationStateManager } from './SegmentationStateManager';
 function destroy() {
     defaultSegmentationStateManager.resetState();
 }
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };

package/dist/esm/tools/annotation/CircleROITool.js

@@ -1,5 +1,5 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, EPSILON, } from '@cornerstonejs/core';
 import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
@@ -507,11 +507,14 @@ class CircleROITool extends AnnotationTool {
                         (topLeftWorld[1] + bottomRightWorld[1]) / 2,
                         (topLeftWorld[2] + bottomRightWorld[2]) / 2,
                     ];
+                    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
+                    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
+                    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
                     const ellipseObj = {
                         center,
-                        xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-                        yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-                        zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
+                        xRadius: xRadius < EPSILON / 2 ? 0 : xRadius,
+                        yRadius: yRadius < EPSILON / 2 ? 0 : yRadius,
+                        zRadius: zRadius < EPSILON / 2 ? 0 : zRadius,
                     };
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, worldPos1, worldPos2);
                     const isEmptyArea = worldWidth === 0 && worldHeight === 0;

package/dist/esm/tools/annotation/RegionSegmentPlusTool.js

@@ -2,6 +2,7 @@ import { cache, utilities as csUtils, getEnabledElement, } from '@cornerstonejs/
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
 import { calculateGrowCutSeeds } from '../../utilities/segmentation/growCut/runOneClickGrowCut';
+import { ToolModes } from '../../enums';
 class RegionSegmentPlusTool extends GrowCutBaseTool {
     static { this.toolName = 'RegionSegmentPlus'; }
     constructor(toolProps = {}, defaultToolProps = {
@@ -21,6 +22,9 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         this.allowedToProceed = false;
     }
     mouseMoveCallback(evt) {
+        if (this.mode !== ToolModes.Active) {
+            return;
+        }
         const eventData = evt.detail;
         const { currentPoints, element } = eventData;
         const { world: worldPoint } = currentPoints;
@@ -36,7 +40,10 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
     async onMouseStable(evt, worldPoint, element) {
         await super.preMouseDownCallback(evt);
         const refVolume = cache.getVolume(this.growCutData.segmentation.referencedVolumeId);
-        const seeds = calculateGrowCutSeeds(refVolume, worldPoint, {});
+        const seeds = calculateGrowCutSeeds(refVolume, worldPoint, {}) || {
+            positiveSeedIndices: new Set(),
+            negativeSeedIndices: new Set(),
+        };
         const { positiveSeedIndices, negativeSeedIndices } = seeds;
         let cursor;
         if (positiveSeedIndices.size / negativeSeedIndices.size > 20 ||

package/dist/esm/tools/displayTools/Labelmap/labelmapDisplay.js

@@ -172,6 +172,9 @@ function _setLabelmapColorAndOpacity(viewportId, labelmapActorEntry, segmentatio
                     : outlineWidth;
         }
         labelmapActor.getProperty().setLabelOutlineThickness(outlineWidths);
+        labelmapActor.modified();
+        labelmapActor.getProperty().modified();
+        labelmapActor.getMapper().modified();
     }
     else {
         labelmapActor

package/dist/esm/tools/displayTools/Surface/removeSurfaceFromElement.js

@@ -1,10 +1,11 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import { getSurfaceActorUID } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 function removeSurfaceFromElement(element, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const actorEntries = viewport.getActors();
-    const filteredSurfaceActors = actorEntries.filter((actor) => actor.uid.startsWith(getSurfaceActorUID(viewport.id, segmentationId, '')));
+    const filteredSurfaceActors = actorEntries.filter((actor) => actor.representationUID &&
+        typeof actor.representationUID === 'string' &&
+        actor.representationUID.startsWith(segmentationId));
     viewport.removeActors(filteredSurfaceActors.map((actor) => actor.uid));
 }
 export default removeSurfaceFromElement;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -200,8 +200,8 @@ class BrushTool extends LabelmapBaseTool {
             const operationData = this.getOperationData(element);
             if (!this._previewData.preview && !this._previewData.isDrag) {
                 this.applyActiveStrategy(enabledElement, operationData);
-                this.doneEditMemo();
             }
+            this.doneEditMemo();
             this._deactivateDraw(element);
             resetElementCursor(element);
             this.updateCursor(evt);

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.d.ts

@@ -1,4 +1,4 @@
 declare function generateContourSetsFromLabelmap({ segmentations }: {
     segmentations: any;
-}): any[];
+}): Promise<any>;
 export { generateContourSetsFromLabelmap };

package/dist/esm/utilities/contours/generateContourSetsFromLabelmap.js

@@ -1,111 +1,91 @@
-import { cache as cornerstoneCache } from '@cornerstonejs/core';
-import vtkImageMarchingSquares from '@kitware/vtk.js/Filters/General/ImageMarchingSquares';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-import { getDeduplicatedVTKPolyDataPoints } from './getDeduplicatedVTKPolyDataPoints';
-import { findContoursFromReducedSet } from './contourFinder';
+import { cache as cornerstoneCache, getWebWorkerManager, cache, utilities, } from '@cornerstonejs/core';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { WorkerTypes } from '../../enums';
+import { registerComputeWorker } from '../registerComputeWorker';
+import { triggerWorkerProgress } from '../segmentation/utilsForWorker';
+import getOrCreateSegmentationVolume from '../segmentation/getOrCreateSegmentationVolume';
 const { Labelmap } = SegmentationRepresentations;
-function generateContourSetsFromLabelmap({ segmentations }) {
-    console.warn('Deprecation Alert: This function will be removed in a future version of Cornerstone Tools. Please use the worker version of this function in computeWorker.');
-    const { representationData, segments = [0, 1] } = segmentations;
-    const { volumeId: segVolumeId } = representationData[Labelmap];
+async function generateContourSetsFromLabelmap({ segmentations }) {
+    registerComputeWorker();
+    triggerWorkerProgress(WorkerTypes.GENERATE_CONTOUR_SETS, 0);
+    const { representationData, segments = [0, 1], segmentationId, } = segmentations;
+    let { volumeId: segVolumeId } = representationData[Labelmap];
+    if (!segVolumeId) {
+        const segVolume = getOrCreateSegmentationVolume(segmentationId);
+        if (segVolume) {
+            segVolumeId = segVolume.volumeId;
+        }
+    }
     const vol = cornerstoneCache.getVolume(segVolumeId);
     if (!vol) {
         console.warn(`No volume found for ${segVolumeId}`);
         return;
     }
     const voxelManager = vol.voxelManager;
-    const segData = voxelManager.getCompleteScalarDataArray();
-    const numSlices = vol.dimensions[2];
-    const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
-    for (let z = 0; z < numSlices; z++) {
-        for (let y = 0; y < vol.dimensions[1]; y++) {
-            const index = y * vol.dimensions[0] + z * pixelsPerSlice;
-            segData[index] = 0;
-            segData[index + vol.dimensions[0] - 1] = 0;
-        }
-    }
-    const ContourSets = [];
-    const { FrameOfReferenceUID } = vol.metadata;
-    const numSegments = segments.length;
-    for (let segIndex = 0; segIndex < numSegments; segIndex++) {
-        const segment = segments[segIndex];
-        if (!segment) {
-            continue;
+    const segScalarData = voxelManager.getCompleteScalarDataArray();
+    const segmentationInfo = {
+        scalarData: segScalarData,
+        dimensions: vol.dimensions,
+        spacing: vol.imageData.getSpacing(),
+        origin: vol.imageData.getOrigin(),
+        direction: vol.imageData.getDirection(),
+    };
+    const indices = Array.isArray(segments)
+        ? segments
+            .filter((segment) => segment !== null)
+            .map((segment) => segment.segmentIndex || segment)
+        : Object.values(segments)
+            .filter((segment) => segment !== null)
+            .map((segment) => segment.segmentIndex || segment);
+    const contourSets = await getWebWorkerManager().executeTask('compute', 'generateContourSetsFromLabelmapVolume', {
+        segmentation: segmentationInfo,
+        indices,
+        mode: 'individual',
+    });
+    const refImages = vol.imageIds.map((imageId) => {
+        const refImageId = cache.getImage(imageId)?.referencedImageId;
+        return refImageId ? cache.getImage(refImageId) : undefined;
+    });
+    const refImageDataMetadata = refImages.map((image) => {
+        return utilities.getImageDataMetadata(image);
+    });
+    const processedContourSets = contourSets
+        .map((contourSet) => {
+        const segment = segments[contourSet.segment.segmentIndex] || {};
+        if (!contourSet.sliceContours.length) {
+            return null;
         }
-        const sliceContours = [];
-        const scalars = vtkDataArray.newInstance({
-            name: 'Scalars',
-            numberOfComponents: 1,
-            size: pixelsPerSlice * numSlices,
-            dataType: 'Uint8Array',
-        });
-        const { containedSegmentIndices } = segment;
-        for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
-            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
-                continue;
-            }
-            const frameStart = sliceIndex * pixelsPerSlice;
-            try {
-                for (let i = 0; i < pixelsPerSlice; i++) {
-                    const value = segData[i + frameStart];
-                    if (value === segIndex || containedSegmentIndices?.has(value)) {
-                        scalars.setValue(i + frameStart, 1);
-                    }
-                    else {
-                        scalars.setValue(i, 0);
-                    }
-                }
-                const mSquares = vtkImageMarchingSquares.newInstance({
-                    slice: sliceIndex,
-                });
-                const imageDataCopy = vtkImageData.newInstance();
-                imageDataCopy.shallowCopy(vol.imageData);
-                imageDataCopy.getPointData().setScalars(scalars);
-                mSquares.setInputData(imageDataCopy);
-                const cValues = [1];
-                mSquares.setContourValues(cValues);
-                mSquares.setMergePoints(false);
-                const msOutput = mSquares.getOutputData();
-                const reducedSet = getDeduplicatedVTKPolyDataPoints(msOutput);
-                if (reducedSet.points?.length) {
-                    const contours = findContoursFromReducedSet(reducedSet.lines);
-                    sliceContours.push({
-                        contours,
-                        polyData: reducedSet,
-                        FrameNumber: sliceIndex + 1,
-                        sliceIndex,
-                        FrameOfReferenceUID,
-                    });
-                }
-            }
-            catch (e) {
-                console.warn(sliceIndex);
-                console.warn(e);
+        const p1 = contourSet.sliceContours[0].polyData.points[0];
+        let refImageId;
+        if (p1) {
+            const refImageIndex = refImageDataMetadata.findIndex((imageDataMetadata) => {
+                const { scanAxisNormal, origin } = imageDataMetadata;
+                const plane = utilities.planar.planeEquation(scanAxisNormal, origin);
+                return utilities.planar.isPointOnPlane(p1, plane);
+            });
+            if (refImageIndex !== -1) {
+                refImageId = refImages[refImageIndex].imageId;
             }
         }
-        const metadata = {
-            FrameOfReferenceUID,
-        };
-        const ContourSet = {
+        return {
             label: segment.label,
             color: segment.color,
-            metadata,
-            sliceContours,
+            metadata: {
+                FrameOfReferenceUID: vol.metadata.FrameOfReferenceUID,
+                referencedImageId: refImageId,
+            },
+            sliceContours: contourSet.sliceContours.map((contourData) => ({
+                contours: contourData.contours,
+                polyData: contourData.polyData,
+                FrameNumber: contourData.sliceIndex + 1,
+                sliceIndex: contourData.sliceIndex,
+                FrameOfReferenceUID: vol.metadata.FrameOfReferenceUID,
+                referencedImageId: refImageId,
+            })),
         };
-        ContourSets.push(ContourSet);
-    }
-    return ContourSets;
-}
-function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
-    const startIdx = sliceIndex * pixelsPerSlice;
-    const endIdx = startIdx + pixelsPerSlice;
-    for (let i = startIdx; i < endIdx; i++) {
-        if (segData[i] === segIndex) {
-            return false;
-        }
-    }
-    return true;
+    })
+        .filter((contourSet) => contourSet !== null);
+    triggerWorkerProgress(WorkerTypes.GENERATE_CONTOUR_SETS, 100);
+    return processedContourSets;
 }
 export { generateContourSetsFromLabelmap };

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

@@ -39,4 +39,5 @@ import { getPixelValueUnits, getPixelValueUnitsImageId } from './getPixelValueUn
 import * as geometricSurfaceUtils from './geometricSurfaceUtils';
 import setAnnotationLabel from './setAnnotationLabel';
 import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, };
+import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };

package/dist/esm/utilities/index.js

@@ -39,4 +39,5 @@ import { getPixelValueUnits, getPixelValueUnitsImageId, } from './getPixelValueU
 import * as geometricSurfaceUtils from './geometricSurfaceUtils';
 import setAnnotationLabel from './setAnnotationLabel';
 import { moveAnnotationToViewPlane } from './moveAnnotationToViewPlane';
-export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, };
+import getOrCreateImageVolume from './segmentation/getOrCreateImageVolume';
+export { math, planar, viewportFilters, drawing, debounce, dynamicVolume, throttle, orientation, isObject, touch, triggerEvent, calibrateImageSpacing, getCalibratedLengthUnitsAndScale, getCalibratedProbeUnitsAndValue, getCalibratedAspect, getPixelValueUnits, getPixelValueUnitsImageId, segmentation, contours, triggerAnnotationRenderForViewportIds, triggerAnnotationRenderForToolGroupIds, triggerAnnotationRender, getSphereBoundsInfo, getAnnotationNearPoint, getViewportForAnnotation, getAnnotationNearPointOnEnabledElement, viewport, cine, boundingBox, rectangleROITool, planarFreehandROITool, stackPrefetch, stackContextPrefetch, roundNumber, pointToString, polyDataUtils, voi, AnnotationMultiSlice, contourSegmentation, annotationHydration, getClosestImageIdForStackViewport, pointInSurroundingSphereCallback, normalizeViewportPlane, IslandRemoval, geometricSurfaceUtils, setAnnotationLabel, moveAnnotationToViewPlane, getOrCreateImageVolume, };

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

@@ -48,6 +48,15 @@ async function calculateForVolume({ segmentationIds, segmentIndex }) {
         direction: referenceVolume.direction,
         scalarData: referenceVolume.voxelManager.getCompleteScalarDataArray(),
     };
+    if (imageInfo.scalarData.length === 0 ||
+        segmentationInfo.scalarData.length === 0) {
+        return {
+            [segmentIndex]: {
+                name: 'TMTV',
+                value: 0,
+            },
+        };
+    }
     const stats = await getWebWorkerManager().executeTask('compute', 'computeMetabolicStats', {
         segmentationInfo,
         imageInfo,

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

@@ -1 +1 @@
-export default function contourAndFindLargestBidirectional(segmentation: any): any;
+export default function contourAndFindLargestBidirectional(segmentation: any): Promise<any>;

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

@@ -1,8 +1,8 @@
 import { generateContourSetsFromLabelmap } from '../contours';
 import findLargestBidirectional from './findLargestBidirectional';
 import getOrCreateSegmentationVolume from './getOrCreateSegmentationVolume';
-export default function contourAndFindLargestBidirectional(segmentation) {
-    const contours = generateContourSetsFromLabelmap({
+export default async function contourAndFindLargestBidirectional(segmentation) {
+    const contours = await generateContourSetsFromLabelmap({
         segmentations: segmentation,
     });
     if (!contours?.length || !contours[0].sliceContours.length) {

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

@@ -13,5 +13,5 @@ export type SegmentContourActionConfiguration = {
     segmentData?: Map<number, Segment>;
     toolGroupId?: string;
 };
-export default function segmentContourAction(element: HTMLDivElement, configuration: any): any;
+export default function segmentContourAction(element: HTMLDivElement, configuration: any): Promise<any>;
 export declare function defaultGetSegment(enabledElement: Types.IEnabledElement, configuration: SegmentContourActionConfiguration): Segment;

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

@@ -5,7 +5,7 @@ import createBidirectionalToolData from './createBidirectionalToolData';
 import BidirectionalTool from '../../tools/annotation/BidirectionalTool';
 import { getSegmentations } from '../../stateManagement/segmentation/getSegmentations';
 import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
-export default function segmentContourAction(element, configuration) {
+export default async function segmentContourAction(element, configuration) {
     console.warn('Deprecation Alert: There is a new getSegmentLargestBidirectional function that handles volume, stack and individual segment cases properly. This function is deprecated and will be removed in a future version.');
     const { data: configurationData } = configuration;
     const enabledElement = getEnabledElement(element);
@@ -36,13 +36,14 @@ export default function segmentContourAction(element, configuration) {
         });
     }
     let newBidirectional;
-    existingLargestBidirectionals.forEach((existingLargestBidirectional) => {
+    existingLargestBidirectionals.forEach(async (existingLargestBidirectional) => {
         const segments = [];
-        const updateSegment = existingLargestBidirectional.data.segment;
+        const updateSegment = existingLargestBidirectional.data
+            .segment;
         const { segmentIndex, segmentationId } = updateSegment;
         segments[segmentIndex] = updateSegment;
         annotationState.removeAnnotation(existingLargestBidirectional.annotationUID);
-        const bidirectionalData = contourAndFindLargestBidirectional({
+        const bidirectionalData = await contourAndFindLargestBidirectional({
             ...segmentationsList.find((segmentation) => segmentation.segmentationId === segmentationId),
             segments,
         });

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

@@ -84,6 +84,9 @@ export const prepareStackDataForWorker = (segImageIds) => {
         const refImageId = segImage.referencedImageId;
         if (refImageId) {
             const refImage = cache.getImage(refImageId);
+            if (!refImage) {
+                continue;
+            }
             const refPixelData = refImage.getPixelData();
             const refVoxelManager = refImage.voxelManager;
             const refSpacing = [

package/dist/esm/workers/computeWorker.js

@@ -305,8 +305,12 @@ const computeWorker = {
         return bidirectionalResults;
     },
     generateContourSetsFromLabelmapVolume: (args) => {
-        const { segmentation, indices, imageData } = args;
-        const { voxelManager, dimensions, scalarData, origin, direction, spacing } = segmentation;
+        const { segmentation, indices } = args;
+        const { dimensions, scalarData, origin, direction, spacing } = segmentation;
+        let imageData = args.imageData;
+        if (!imageData) {
+            imageData = computeWorker.createVTKImageData(dimensions, origin, direction, spacing);
+        }
         const numSlices = dimensions[2];
         const pixelsPerSlice = dimensions[0] * dimensions[1];
         const segments = computeWorker.createSegmentsFromIndices(indices);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "3.8.3",
+  "version": "3.8.5",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -103,7 +103,7 @@
     "canvas": "^3.1.0"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^3.8.3",
+    "@cornerstonejs/core": "^3.8.5",
     "@kitware/vtk.js": "32.12.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -122,5 +122,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f4dd844bc47c06493547a4754c955e6854475d3f"
+  "gitHead": "782551a1523d3619fa002b9b5bb2991519fb5f40"
 }