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

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

@@ -1,2 +1,2 @@
-import { Segmentation } from '../../types/SegmentationStateTypes';
+import type { Segmentation } from '../../types/SegmentationStateTypes';
 export default function getDefaultRepresentationConfig(segmentation: Segmentation): import("../../types/LabelmapTypes").LabelmapConfig;

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

@@ -1,5 +1,5 @@
 import { cache, utilities } from '@cornerstonejs/core';
-import { getSegmentation, getRepresentationsBySegmentationId, getLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getSegmentationRepresentationsForSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { viewport, searchRadius }) {
     const segmentation = getSegmentation(segmentationId);
@@ -16,20 +16,23 @@ export function getSegmentIndexAtLabelmapBorder(segmentationId, worldPoint, { vi
         const onEdge = isSegmentOnEdgeCanvas(canvasPoint, segmentIndex, viewport, imageData, searchRadius);
         return onEdge ? segmentIndex : undefined;
     }
-    const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
     const currentImageId = viewport.getCurrentImageId();
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;
     }
-    const segmentationRepresentations = getRepresentationsBySegmentationId(segmentation.segmentationId);
+    const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentation.segmentationId);
     const { segmentationRepresentationUID } = segmentationRepresentations[0];
     const segmentationActor = viewport.getActor(segmentationRepresentationUID);
     const imageData = segmentationActor?.actor.getMapper().getInputData();
     const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
     const dimensions = imageData.getDimensions();
     const voxelManager = (imageData.voxelManager ||
-        utilities.VoxelManager.createVolumeVoxelManager(dimensions, imageData.getPointData().getScalars().getData()));
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
     const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
     const onEdge = isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex);
     return onEdge ? segmentIndex : undefined;
@@ -58,7 +61,7 @@ function isSegmentOnEdgeIJK(indexIJK, dimensions, voxelManager, segmentIndex, se
             indexIJK[1] + deltaJ,
             indexIJK[2] + deltaK,
         ];
-        return voxelManager.getAtIJK(...neighborIJK);
+        return voxelManager.getAtIJK(neighborIJK[0], neighborIJK[1], neighborIJK[2]);
     };
     return isSegmentOnEdge(getNeighborIndex, segmentIndex, searchRadius);
 }

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
-import { Segmentation } from '../../types';
+import type { Segmentation } from '../../types';
 type Options = {
     representationType?: SegmentationRepresentations;
     viewport?: Types.IViewport;

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

@@ -1,6 +1,6 @@
 import { cache, utilities } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
-import { getSegmentation, getRepresentationsBySegmentationId, getLabelmapImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation, getSegmentationRepresentationsForSegmentation, getCurrentLabelmapImageIdForViewport, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { getAnnotation } from '../../stateManagement';
 import { isPointInsidePolyline3D } from '../math/polyline';
@@ -31,19 +31,22 @@ export function getSegmentIndexAtWorldForLabelmap(segmentation, worldPoint, { vi
         const segmentIndex = segmentationVolume.imageData.getScalarValueFromWorld(worldPoint);
         return segmentIndex;
     }
-    const segmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentation.segmentationId);
+    const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentation.segmentationId);
     const image = cache.getImage(segmentationImageId);
     if (!image) {
         return;
     }
-    const segmentationRepresentations = getRepresentationsBySegmentationId(segmentation.segmentationId);
+    const segmentationRepresentations = getSegmentationRepresentationsForSegmentation(segmentation.segmentationId);
     const { segmentationRepresentationUID } = segmentationRepresentations[0];
     const segmentationActor = viewport.getActor(segmentationRepresentationUID);
     const imageData = segmentationActor?.actor.getMapper().getInputData();
     const indexIJK = utilities.transformWorldToIndex(imageData, worldPoint);
     const dimensions = imageData.getDimensions();
     const voxelManager = (imageData.voxelManager ||
-        utilities.VoxelManager.createVolumeVoxelManager(dimensions, imageData.getPointData().getScalars().getData()));
+        utilities.VoxelManager.createScalarVolumeVoxelManager({
+            dimensions,
+            scalarData: imageData.getPointData().getScalars().getData(),
+        }));
     const segmentIndex = voxelManager.getAtIJKPoint(indexIJK);
     return segmentIndex;
 }

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

@@ -63,17 +63,16 @@ function handleLabelmapSegmentation(segmentation, segmentationId) {
 }
 function addVolumeSegmentIndices(keySet, segmentationId) {
     const volume = cache.getVolume(segmentationId);
-    const scalarData = volume.getScalarData();
-    scalarData.forEach((segmentIndex) => {
-        if (segmentIndex !== 0) {
-            keySet.add(segmentIndex);
+    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.getPixelData();
+        const scalarData = image.voxelManager.getScalarData();
         scalarData.forEach((segmentIndex) => {
             if (segmentIndex !== 0) {
                 keySet.add(segmentIndex);

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

@@ -4,7 +4,7 @@ import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
 import isValidRepresentationConfig from './isValidRepresentationConfig';
 import getDefaultRepresentationConfig from './getDefaultRepresentationConfig';
 import createLabelmapVolumeForViewport from './createLabelmapVolumeForViewport';
-import { triggerSegmentationRender } from './triggerSegmentationRender';
+import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId } from './triggerSegmentationRender';
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
@@ -18,4 +18,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

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

@@ -4,7 +4,7 @@ import createMergedLabelmapForIndex from './createMergedLabelmapForIndex';
 import isValidRepresentationConfig from './isValidRepresentationConfig';
 import getDefaultRepresentationConfig from './getDefaultRepresentationConfig';
 import createLabelmapVolumeForViewport from './createLabelmapVolumeForViewport';
-import { triggerSegmentationRender } from './triggerSegmentationRender';
+import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, } from './triggerSegmentationRender';
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
@@ -18,4 +18,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './utilities';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, isValidRepresentationConfig, getDefaultRepresentationConfig, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

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

@@ -1,2 +1,2 @@
-import { RepresentationConfig } from '../../types/SegmentationStateTypes';
+import type { RepresentationConfig } from '../../types/SegmentationStateTypes';
 export default function isValidRepresentationConfig(representationType: string, config: RepresentationConfig): boolean;

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { ThresholdInformation } from './utilities';
+import type { ThresholdInformation } from './utilities';
 export type ThresholdOptions = {
     numSlicesToProject?: number;
     overwrite: boolean;

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

@@ -9,8 +9,9 @@ function rectangleROIThresholdVolumeByRange(annotationUIDs, segmentationVolume,
     _validateAnnotations(annotations);
     let boundsIJK;
     for (let i = 0; i < thresholdVolumeInformation.length; i++) {
-        const volumeSize = thresholdVolumeInformation[i].volume.getScalarData().length;
-        if (volumeSize === segmentationVolume.getScalarData().length || i === 0) {
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === segmentationVolume.voxelManager.getScalarDataLength() ||
+            i === 0) {
             boundsIJK = getBoundsIJKFromRectangleAnnotations(annotations, thresholdVolumeInformation[i].volume, options);
         }
     }

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

@@ -3,7 +3,7 @@ export type Segment = {
     segmentationId: string;
     segmentIndex: number;
     label: string;
-    style?: any;
+    style?: Record<string, unknown>;
     containedSegmentIndices?: (number: any) => boolean;
 };
 export type SegmentContourActionConfiguration = {

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

@@ -18,16 +18,16 @@ export default function segmentContourAction(element, configuration) {
     const bidirectionals = annotationState.getAnnotations(this.toolName || BidirectionalTool.toolName, FrameOfReferenceUID);
     let hasExistingActiveSegment = false;
     const existingLargestBidirectionals = bidirectionals.filter((existingBidirectionalItem) => {
-        const { segment } = existingBidirectionalItem.data;
+        const segment = existingBidirectionalItem.data.segment;
         if (!segment) {
-            return;
+            return false;
         }
         if (segment.segmentationId === segmentationId &&
             segment.segmentIndex === segmentIndex) {
             hasExistingActiveSegment = true;
             existingBidirectionalItem.data.segment = segment;
         }
-        return !!segment;
+        return true;
     });
     if (!hasExistingActiveSegment) {
         existingLargestBidirectionals.push({
@@ -37,7 +37,7 @@ export default function segmentContourAction(element, configuration) {
     let newBidirectional;
     existingLargestBidirectionals.forEach((existingLargestBidirectional) => {
         const segments = [];
-        const { segment: updateSegment } = existingLargestBidirectional.data;
+        const updateSegment = existingLargestBidirectional.data.segment;
         const { segmentIndex, segmentationId } = updateSegment;
         segments[segmentIndex] = updateSegment;
         annotationState.removeAnnotation(existingLargestBidirectional.annotationUID);

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

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
-import { ThresholdInformation } from './utilities';
+import type { Types } from '@cornerstonejs/core';
+import type { ThresholdInformation } from './utilities';
 declare function thresholdSegmentationByRange(segmentationVolume: Types.IImageVolume, segmentationIndex: number, thresholdVolumeInformation: ThresholdInformation[], overlapType: number): Types.IImageVolume;
 export default thresholdSegmentationByRange;

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

@@ -1,26 +1,29 @@
-import { pointInShapeCallback } from '../../utilities';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import { getVoxelOverlap, processVolumes, } from './utilities';
+import { getVoxelOverlap, processVolumes } from './utilities';
 function thresholdSegmentationByRange(segmentationVolume, segmentationIndex, thresholdVolumeInformation, overlapType) {
-    const scalarData = segmentationVolume.getScalarData();
     const { baseVolumeIdx, volumeInfoList } = processVolumes(segmentationVolume, thresholdVolumeInformation);
+    const { voxelManager } = volumeInfoList[baseVolumeIdx];
+    const refVoxelManager = voxelManager;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
+    const segVoxelManager = segmentationVolume.voxelManager;
     volumeInfoList.forEach((volumeInfo) => {
         const { volumeSize } = volumeInfo;
-        if (volumeSize === scalarData.length) {
-            _handleSameSizeVolume(scalarData, segmentationIndex, volumeInfo);
+        if (volumeSize === scalarDataLength) {
+            _handleSameSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo);
         }
         else {
-            _handleDifferentSizeVolume(scalarData, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType);
+            _handleDifferentSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType);
         }
     });
     triggerSegmentationDataModified(segmentationVolume.volumeId);
     return segmentationVolume;
 }
-function _handleDifferentSizeVolume(scalarData, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType) {
+function _handleDifferentSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo, volumeInfoList, baseVolumeIdx, overlapType) {
     const { imageData, lower, upper, dimensions } = volumeInfo;
     let total, overlaps, range;
-    for (let i = 0; i < scalarData.length; i++) {
-        if (scalarData[i] === segmentationIndex) {
+    const segScalarDataLength = segVoxelManager.getScalarDataLength();
+    for (let i = 0; i < segScalarDataLength; i++) {
+        if (segScalarDataLength.getAtIndex(i) === segmentationIndex) {
             const overlapBounds = getVoxelOverlap(imageData, dimensions, volumeInfoList[baseVolumeIdx].spacing, volumeInfoList[baseVolumeIdx].imageData.getPoint(i));
             const callbackOverlap = ({ value }) => {
                 total = total + 1;
@@ -32,19 +35,23 @@ function _handleDifferentSizeVolume(scalarData, segmentationIndex, volumeInfo, v
             overlaps = 0;
             range = { lower, upper };
             let overlapTest = false;
-            pointInShapeCallback(imageData, () => true, callbackOverlap, overlapBounds);
+            segVoxelManager.forEach(callbackOverlap, {
+                imageData,
+                boundsIJK: overlapBounds,
+            });
             overlapTest = overlapType === 0 ? overlaps > 0 : overlaps === total;
-            scalarData[i] = overlapTest ? segmentationIndex : 0;
+            segVoxelManager.setAtIndex(i, overlapTest ? segmentationIndex : 0);
         }
     }
     return { total, range, overlaps };
 }
-function _handleSameSizeVolume(scalarData, segmentationIndex, volumeInfo) {
-    const { referenceValues, lower, upper } = volumeInfo;
-    for (let i = 0; i < scalarData.length; i++) {
-        if (scalarData[i] === segmentationIndex) {
-            const value = referenceValues[i];
-            scalarData[i] = value >= lower && value <= upper ? segmentationIndex : 0;
+function _handleSameSizeVolume(segVoxelManager, refVoxelManager, segmentationIndex, volumeInfo) {
+    const { lower, upper } = volumeInfo;
+    const scalarDataLength = segVoxelManager.getScalarDataLength();
+    for (let i = 0; i < scalarDataLength; i++) {
+        if (segVoxelManager.getAtIndex[i] === segmentationIndex) {
+            const value = refVoxelManager.getAtIndex(i);
+            segVoxelManager.setAtIndex(i, value >= lower && value <= upper ? segmentationIndex : 0);
         }
     }
 }

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

@@ -1,6 +1,6 @@
-import { Types } from '@cornerstonejs/core';
-import { BoundsIJK } from '../../types';
-import { ThresholdInformation } from './utilities';
+import type { Types } from '@cornerstonejs/core';
+import type { BoundsIJK } from '../../types';
+import type { ThresholdInformation } from './utilities';
 export type ThresholdRangeOptions = {
     overwrite: boolean;
     boundsIJK: BoundsIJK;

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

@@ -1,14 +1,14 @@
-import { pointInShapeCallback } from '../../utilities';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
-import { getVoxelOverlap, processVolumes, } from './utilities';
+import { getVoxelOverlap, processVolumes } from './utilities';
 function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation, options) {
     const { imageData: segmentationImageData } = segmentationVolume;
-    const scalarData = segmentationVolume.getScalarData();
     const { overwrite, boundsIJK } = options;
     const overlapType = options?.overlapType || 0;
+    const segVoxelManager = segmentationVolume.voxelManager;
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
     if (overwrite) {
-        for (let i = 0; i < scalarData.length; i++) {
-            scalarData[i] = 0;
+        for (let i = 0; i < scalarDataLength; i++) {
+            segVoxelManager.setAtIndex(i, 0);
         }
     }
     const { baseVolumeIdx, volumeInfoList } = processVolumes(segmentationVolume, thresholdVolumeInformation);
@@ -26,7 +26,11 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
         overlaps = 0;
         range = { lower, upper };
         let overlapTest = false;
-        pointInShapeCallback(imageData, () => true, callbackOverlap, overlapBounds);
+        const { voxelManager } = imageData.get('voxelManager');
+        voxelManager.forEach(callbackOverlap, {
+            imageData,
+            boundsIJK: overlapBounds,
+        });
         if (overlapType === 0) {
             overlapTest = overlaps > 0;
         }
@@ -36,9 +40,10 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
         return overlapTest;
     };
     const testRange = (volumeInfo, pointIJK) => {
-        const { imageData, referenceValues, lower, upper } = volumeInfo;
-        const offset = imageData.computeOffsetIndex(pointIJK);
-        const value = referenceValues[offset];
+        const { imageData, lower, upper } = volumeInfo;
+        const voxelManager = imageData.get('voxelManager').voxelManager;
+        const offset = voxelManager.toIndex(pointIJK);
+        const value = voxelManager.getAtIndex(offset);
         if (value <= lower || value >= upper) {
             return false;
         }
@@ -49,7 +54,7 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
     const callback = ({ index, pointIJK, pointLPS }) => {
         let insert = volumeInfoList.length > 0;
         for (let i = 0; i < volumeInfoList.length; i++) {
-            if (volumeInfoList[i].volumeSize === scalarData.length) {
+            if (volumeInfoList[i].volumeSize === scalarDataLength) {
                 insert = testRange(volumeInfoList[i], pointIJK);
             }
             else {
@@ -60,10 +65,14 @@ function thresholdVolumeByRange(segmentationVolume, thresholdVolumeInformation,
             }
         }
         if (insert) {
-            scalarData[index] = options.segmentIndex || 1;
+            segVoxelManager.setAtIndex(index, options.segmentIndex || 1);
         }
     };
-    pointInShapeCallback(segmentationImageData, () => true, callback, boundsIJK);
+    const voxelManager = segmentationVolume.voxelManager;
+    voxelManager.forEach(callback, {
+        imageData: segmentationImageData,
+        boundsIJK,
+    });
     triggerSegmentationDataModified(segmentationVolume.volumeId);
     return segmentationVolume;
 }

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

@@ -1,3 +1,3 @@
-declare function triggerSegmentationRender(segmentationId?: string): void;
-export { triggerSegmentationRender };
-export default triggerSegmentationRender;
+declare function triggerSegmentationRender(viewportId?: string): void;
+declare function triggerSegmentationRenderBySegmentationId(segmentationId?: string): void;
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId };

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

@@ -1,6 +1,8 @@
-import { segmentationRenderingEngine } from '../../tools/displayTools/SegmentationRenderingEngine';
-function triggerSegmentationRender(segmentationId) {
-    segmentationRenderingEngine.renderSegmentations(segmentationId);
+import { segmentationRenderingEngine } from '../../stateManagement/segmentation/SegmentationRenderingEngine';
+function triggerSegmentationRender(viewportId) {
+    segmentationRenderingEngine.renderSegmentationsForViewport(viewportId);
 }
-export { triggerSegmentationRender };
-export default triggerSegmentationRender;
+function triggerSegmentationRenderBySegmentationId(segmentationId) {
+    segmentationRenderingEngine.renderSegmentation(segmentationId);
+}
+export { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId };

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

@@ -1,12 +1,22 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export type ThresholdInformation = {
     volume: Types.IImageVolume;
     lower: number;
     upper: number;
 };
+export type VolumeInfo = {
+    imageData: vtkImageData;
+    lower: number;
+    upper: number;
+    spacing: Types.Point3;
+    dimensions: Types.Point3;
+    volumeSize: number;
+    voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+};
 export declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];
 export declare function getVoxelOverlap(imageData: any, dimensions: any, voxelSpacing: any, voxelCenter: any): [Types.Point2, Types.Point2, null] | [Types.Point2, Types.Point2, Types.Point2];
 export declare function processVolumes(segmentationVolume: Types.IImageVolume, thresholdVolumeInformation: ThresholdInformation[]): {
-    volumeInfoList: any[];
+    volumeInfoList: VolumeInfo[];
     baseVolumeIdx: number;
 };

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

@@ -39,27 +39,26 @@ export function getVoxelOverlap(imageData, dimensions, voxelSpacing, voxelCenter
 }
 export function processVolumes(segmentationVolume, thresholdVolumeInformation) {
     const { spacing: segmentationSpacing } = segmentationVolume;
-    const scalarData = segmentationVolume.getScalarData();
+    const scalarDataLength = segmentationVolume.voxelManager.getScalarDataLength();
     const volumeInfoList = [];
     let baseVolumeIdx = 0;
     for (let i = 0; i < thresholdVolumeInformation.length; i++) {
-        const { imageData, spacing, dimensions } = thresholdVolumeInformation[i].volume;
-        const volumeSize = thresholdVolumeInformation[i].volume.getScalarData().length;
-        if (volumeSize === scalarData.length &&
+        const { imageData, spacing, dimensions, voxelManager } = thresholdVolumeInformation[i].volume;
+        const volumeSize = thresholdVolumeInformation[i].volume.voxelManager.getScalarDataLength();
+        if (volumeSize === scalarDataLength &&
             equalsCheck(spacing, segmentationSpacing)) {
             baseVolumeIdx = i;
         }
-        const referenceValues = imageData.getPointData().getScalars().getData();
         const lower = thresholdVolumeInformation[i].lower;
         const upper = thresholdVolumeInformation[i].upper;
         volumeInfoList.push({
             imageData,
-            referenceValues,
             lower,
             upper,
             spacing,
             dimensions,
             volumeSize,
+            voxelManager,
         });
     }
     return {

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

@@ -1,4 +1,4 @@
-import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, getConfiguration as getCoreConfiguration, } from '@cornerstonejs/core';
+import { imageLoader, Enums, eventTarget, imageLoadPoolManager, cache, } from '@cornerstonejs/core';
 import { addToolState, getToolState } from './state';
 import { getStackData, requestType, priority, clearFromImageIds, getPromiseRemovedHandler, } from './stackPrefetchUtils';
 let configuration = {
@@ -12,7 +12,10 @@ let resetPrefetchTimeout;
 const resetPrefetchDelay = 5;
 const enable = (element) => {
     const stack = getStackData(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
@@ -26,6 +29,9 @@ const enable = (element) => {
 };
 function prefetch(element) {
     const stack = getStackData(element);
+    if (!stack) {
+        return;
+    }
     if (!stack?.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
@@ -34,8 +40,9 @@ function prefetch(element) {
     if (!stackPrefetchData) {
         return;
     }
-    const stackPrefetch = stackPrefetchData || {};
-    stackPrefetch.enabled &&= stackPrefetch.indicesToRequest?.length;
+    const stackPrefetch = (stackPrefetchData || {});
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
     if (stackPrefetch.enabled === false) {
         return;
     }
@@ -99,15 +106,9 @@ function prefetch(element) {
     const requestFn = (imageId, options) => imageLoader
         .loadAndCacheImage(imageId, options)
         .then(() => doneCallback(imageId));
-    const { useNorm16Texture, preferSizeOverAccuracy } = getCoreConfiguration().rendering;
-    const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
     stackPrefetch.indicesToRequest.forEach((imageIdIndex) => {
         const imageId = stack.imageIds[imageIdIndex];
         const options = {
-            targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
-            },
-            useNativeDataType,
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {
@@ -131,27 +132,31 @@ function onImageUpdated(e) {
 const signum = (x) => (x < 0 ? -1 : 1);
 const updateToolState = (element, usage) => {
     const stack = getStackData(element);
-    if (!stack || !stack.imageIds || stack.imageIds.length === 0) {
+    if (!stack) {
+        return;
+    }
+    if (!stack.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
     const { currentImageIdIndex } = stack;
     let { maxAfter = 2, minBefore = 2 } = configuration;
     const { directionExtraImages = 10 } = configuration;
-    const stackPrefetchData = getToolState(element) || {
-        indicesToRequest: [],
-        currentImageIdIndex,
-        stackCount: 0,
-        enabled: true,
-        direction: 1,
-        stats: {
-            start: Date.now(),
-            imageIds: new Map(),
-            decodeTimeInMS: 0,
-            loadTimeInMS: 0,
-            totalBytes: 0,
-        },
-    };
+    const stackPrefetchData = getToolState(element) ||
+        {
+            indicesToRequest: [],
+            currentImageIdIndex,
+            stackCount: 0,
+            enabled: true,
+            direction: 1,
+            stats: {
+                start: Date.now(),
+                imageIds: new Map(),
+                decodeTimeInMS: 0,
+                loadTimeInMS: 0,
+                totalBytes: 0,
+            },
+        };
     const delta = currentImageIdIndex - stackPrefetchData.currentImageIdIndex;
     stackPrefetchData.direction = signum(delta);
     stackPrefetchData.currentImageIdIndex = currentImageIdIndex;

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

@@ -12,14 +12,15 @@ function prefetch(element) {
     if (!stackPrefetchData) {
         return;
     }
-    const stackPrefetch = stackPrefetchData || {};
+    const stackPrefetch = (stackPrefetchData || {});
     const stack = getStackData(element);
     if (!stack?.imageIds?.length) {
         console.warn('CornerstoneTools.stackPrefetch: No images in stack.');
         return;
     }
     const { currentImageIdIndex } = stack;
-    stackPrefetch.enabled &&= stackPrefetch.indicesToRequest?.length;
+    stackPrefetch.enabled =
+        stackPrefetch.enabled && (stackPrefetch.indicesToRequest?.length ?? 0) > 0;
     if (stackPrefetch.enabled === false) {
         return;
     }
@@ -86,14 +87,8 @@ function prefetch(element) {
         }
     }
     const requestFn = (imageId, options) => imageLoader.loadAndCacheImage(imageId, options);
-    const { useNorm16Texture, preferSizeOverAccuracy } = getCoreConfiguration().rendering;
-    const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
     imageIdsToPrefetch.forEach((imageId) => {
         const options = {
-            targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
-            },
-            useNativeDataType,
             requestType,
         };
         imageLoadPoolManager.addRequest(requestFn.bind(null, imageId, options), requestType, {

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

@@ -35,7 +35,6 @@ export function getStackData(element) {
     }
     const { viewport } = enabledElement;
     if (!(viewport instanceof StackViewport)) {
-        console.warn('stackPrefetch: element must be a StackViewport, VolumeViewport stackPrefetch not yet implemented');
         return null;
     }
     return {
@@ -63,8 +62,8 @@ export function getPromiseRemovedHandler(element) {
         }
         const stackPrefetchData = getToolState(element);
         if (!stackPrefetchData ||
-            !stackPrefetchData.data ||
-            !stackPrefetchData.data.length) {
+            !stackPrefetchData.indicesToRequest ||
+            !stackPrefetchData.indicesToRequest.length) {
             return;
         }
         stackPrefetchData.indicesToRequest.push(imageIdIndex);