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

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.d.ts

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { Types } from '@cornerstonejs/core';
+import type { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 export default function smoothAnnotation(enabledElement: Types.IEnabledElement, annotation: PlanarFreehandROIAnnotation, knotsRatioPercentage: number): boolean;

package/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js

@@ -1,6 +1,6 @@
-import { PlanarFreehandROITool } from '../../tools';
-import { ToolGroupManager } from '../../store';
+import PlanarFreehandROITool from '../../tools/annotation/PlanarFreehandROITool';
 import interpolateSegmentPoints from './interpolation/interpolateSegmentPoints';
+import { getToolGroupForViewport } from '../../store/ToolGroupManager';
 function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercentage) {
     if (!annotation?.data?.polyline || knotsRatioPercentage <= 0) {
         return true;
@@ -9,7 +9,7 @@ function shouldPreventInterpolation(enabledElement, annotation, knotsRatioPercen
         return true;
     }
     const { renderingEngineId, viewportId, FrameOfReferenceUID } = enabledElement;
-    const toolGroup = ToolGroupManager.getToolGroupForViewport(viewportId, renderingEngineId);
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
     if (annotation.metadata.FrameOfReferenceUID !== FrameOfReferenceUID) {
         return true;
     }

package/dist/esm/utilities/planarFreehandROITool/smoothPoints.d.ts

@@ -1,3 +1,11 @@
-import { Types } from '@cornerstonejs/core';
-export declare function shouldSmooth(configuration: Record<any, any>, annotation?: any): boolean;
-export declare function getInterpolatedPoints(configuration: Record<any, any>, points: Types.Point2[], pointsOfReference?: Types.Point2[]): Types.Point2[];
+import type { Types } from '@cornerstonejs/core';
+export declare function shouldSmooth(configuration: Record<string, {
+    smoothOnAdd: boolean;
+    smoothOnEdit: boolean;
+}>, annotation?: any): boolean;
+export declare function getInterpolatedPoints(configuration: Record<string, {
+    smoothOnAdd: boolean;
+    smoothOnEdit: boolean;
+    knotsRatioPercentageOnAdd: number;
+    knotsRatioPercentageOnEdit: number;
+}>, points: Types.Point2[], pointsOfReference?: Types.Point2[]): Types.Point2[];

package/dist/esm/utilities/polyData/utils.d.ts

@@ -1,4 +1,4 @@
-import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
+import type vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import type { Types } from '@cornerstonejs/core';
 export declare function getPoint(points: any, idx: any): Types.Point3;
 export declare function getPolyDataPointIndexes(polyData: vtkPolyData): any[];

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

@@ -1,4 +1,5 @@
-import { Types, VolumeViewport } from '@cornerstonejs/core';
-import { ScrollOptions } from '../types';
-export default function scroll(viewport: Types.IViewport, options: ScrollOptions): void;
+import type { Types } from '@cornerstonejs/core';
+import { VolumeViewport } from '@cornerstonejs/core';
+import type { ScrollOptions } from '../types';
+export default function scroll(viewport: Types.IViewport | Types.IVideoViewport, options: ScrollOptions): void;
 export declare function scrollVolume(viewport: VolumeViewport, volumeId: string, delta: number, scrollSlabs?: boolean): void;

package/dist/esm/utilities/scroll.js

@@ -1,4 +1,4 @@
-import { StackViewport, VolumeViewport, eventTarget, EVENTS, utilities as csUtils, getEnabledElement, VideoViewport, } from '@cornerstonejs/core';
+import { StackViewport, VolumeViewport, eventTarget, EVENTS, utilities as csUtils, getEnabledElement, } from '@cornerstonejs/core';
 export default function scroll(viewport, options) {
     const enabledElement = getEnabledElement(viewport.element);
     if (!enabledElement) {
@@ -8,19 +8,12 @@ export default function scroll(viewport, options) {
         viewport.getImageIds().length === 0) {
         throw new Error('Scroll::Stack Viewport has no images');
     }
-    const { type: viewportType } = viewport;
     const { volumeId, delta, scrollSlabs } = options;
-    if (viewport instanceof StackViewport) {
-        viewport.scroll(delta, options.debounceLoading, options.loop);
-    }
-    else if (viewport instanceof VolumeViewport) {
+    if (viewport instanceof VolumeViewport) {
         scrollVolume(viewport, volumeId, delta, scrollSlabs);
     }
-    else if (viewport instanceof VideoViewport) {
-        viewport.scroll(delta);
-    }
     else {
-        throw new Error(`Not implemented for Viewport Type: ${viewportType}`);
+        viewport.scroll(delta, options.debounceLoading, options.loop);
     }
 }
 export function scrollVolume(viewport, volumeId, delta, scrollSlabs = false) {

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

@@ -1,4 +1,4 @@
-import { AnnotationCompletedEventType, AnnotationModifiedEventType, AnnotationRemovedEventType } from '../../../types/EventTypes';
+import type { AnnotationCompletedEventType, AnnotationModifiedEventType, AnnotationRemovedEventType } from '../../../types/EventTypes';
 import type AnnotationGroupSelector from '../../../types/AnnotationGroupSelector';
 import type { AcceptInterpolationSelector } from '../../../types/InterpolationTypes';
 export default class InterpolationManager {

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushSizeForToolGroup(toolGroupId, brushSize, toolName) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -1,7 +1,7 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
 import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function setBrushThresholdForToolGroup(toolGroupId, threshold, otherArgs = { isDynamic: false }) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {

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

@@ -3,16 +3,7 @@ export default function createLabelmapVolumeForViewport(input: {
     viewportId: string;
     renderingEngineId: string;
     segmentationId?: string;
-    options?: {
-        volumeId: string;
-        scalarData: Float32Array | Uint8Array | Uint16Array | Int16Array;
-        targetBuffer: {
-            type: 'Float32Array' | 'Uint8Array' | 'Uint16Array' | 'Int8Array';
-        };
-        metadata: Types.Metadata;
-        dimensions: Types.Point3;
-        spacing: Types.Point3;
-        origin: Types.Point3;
-        direction: Types.Mat3;
+    options?: Types.LocalVolumeOptions & {
+        volumeId?: string;
     };
 }): Promise<string>;

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

@@ -16,7 +16,7 @@ export default async function createLabelmapVolumeForViewport(input) {
     }
     if (options) {
         const properties = structuredClone(options);
-        await volumeLoader.createLocalVolume(properties, segmentationId);
+        await volumeLoader.createLocalVolume(segmentationId, properties);
     }
     else {
         const { uid: volumeId } = viewport.getDefaultActor();

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

@@ -1,3 +1,3 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function createMergedLabelmapForIndex(labelmaps: Array<Types.IImageVolume>, segmentIndex?: number, volumeId?: string): Types.IImageVolume;
 export default createMergedLabelmapForIndex;

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

@@ -9,12 +9,13 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
         }
     });
     const labelmap = labelmaps[0];
-    const arrayType = labelmap.getScalarData().constructor;
-    const outputData = new arrayType(labelmap.getScalarData().length);
+    const arrayType = labelmap.voxelManager.getConstructor();
+    const outputData = new arrayType(labelmap.voxelManager.getScalarDataLength());
     labelmaps.forEach((labelmap) => {
-        const scalarData = labelmap.getScalarData();
-        for (let i = 0; i < scalarData.length; i++) {
-            if (scalarData[i] === segmentIndex) {
+        const voxelManager = labelmap.voxelManager;
+        const scalarDataLength = voxelManager.getScalarDataLength();
+        for (let i = 0; i < scalarDataLength; i++) {
+            if (voxelManager.getAtIndex(i) === segmentIndex) {
                 outputData[i] = segmentIndex;
             }
         }
@@ -27,8 +28,7 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
         direction: labelmap.direction,
         dimensions: labelmap.dimensions,
     };
-    const preventCache = true;
-    const mergedVolume = volumeLoader.createLocalVolume(options, volumeId, preventCache);
+    const mergedVolume = volumeLoader.createLocalVolume(volumeId, options);
     return mergedVolume;
 }
 export default createMergedLabelmapForIndex;

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

@@ -1,4 +1,4 @@
 import type { FloodFillResult, FloodFillGetter, FloodFillOptions } from '../../types';
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 declare function floodFill(getter: FloodFillGetter, seed: Types.Point2 | Types.Point3, options?: FloodFillOptions): FloodFillResult;
 export default floodFill;

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

@@ -0,0 +1 @@
+export declare function getBrushToolInstances(toolGroupId: string, toolName?: string): any[];

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

@@ -0,0 +1,17 @@
+import { getToolGroup } from '../../store/ToolGroupManager';
+import BrushTool from '../../tools/segmentation/BrushTool';
+export function getBrushToolInstances(toolGroupId, toolName) {
+    const toolGroup = getToolGroup(toolGroupId);
+    if (toolGroup === undefined) {
+        return;
+    }
+    const toolInstances = toolGroup._toolInstances;
+    if (!Object.keys(toolInstances).length) {
+        return;
+    }
+    if (toolName && toolInstances[toolName]) {
+        return [toolInstances[toolName]];
+    }
+    const brushBasedToolInstances = Object.values(toolInstances).filter((toolInstance) => toolInstance instanceof BrushTool);
+    return brushBasedToolInstances;
+}

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.d.ts

@@ -1,4 +1,2 @@
-export declare const setSegmentationDirty: (segmentationId: string) => void;
-export declare const setSegmentationClean: (segmentationId: string) => void;
 declare function getUniqueSegmentIndices(segmentationId: any): any;
 export { getUniqueSegmentIndices };

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

@@ -1,27 +1,8 @@
 import { cache } from '@cornerstonejs/core';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from '../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { SegmentationRepresentations } from '../../enums';
-const segmentIndicesCache = new Map();
-export const setSegmentationDirty = (segmentationId) => {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached) {
-        cached.isDirty = true;
-    }
-};
-export const setSegmentationClean = (segmentationId) => {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached) {
-        cached.isDirty = false;
-    }
-};
-function getCachedSegmentIndices(segmentationId) {
-    const cached = segmentIndicesCache.get(segmentationId);
-    if (cached && !cached.isDirty) {
-        return cached.indices;
-    }
-    return null;
-}
+import { getCachedSegmentIndices, setCachedSegmentIndices } from './utilities';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 function getUniqueSegmentIndices(segmentationId) {
     const cachedResult = getCachedSegmentIndices(segmentationId);
     if (cachedResult) {
@@ -45,7 +26,7 @@ function getUniqueSegmentIndices(segmentationId) {
         default:
             throw new Error(`Unsupported segmentation type: ${segmentation.type}`);
     }
-    segmentIndicesCache.set(segmentationId, { indices, isDirty: false });
+    setCachedSegmentIndices(segmentationId, indices);
     return indices;
 }
 function handleLabelmapSegmentation(segmentation, segmentationId) {
@@ -63,17 +44,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 '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
@@ -17,5 +17,5 @@ import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
 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, };
+import { getBrushToolInstances } from './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 '../../stateManagement/segmentation/SegmentationRenderingEngine';
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
@@ -17,5 +17,5 @@ import { getUniqueSegmentIndices } from './getUniqueSegmentIndices';
 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, };
+import { getBrushToolInstances } from './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/invalidateBrushCursor.js

@@ -1,7 +1,6 @@
 import { getToolGroup } from '../../store/ToolGroupManager';
 import triggerAnnotationRenderForViewportIds from '../triggerAnnotationRenderForViewportIds';
-import { getRenderingEngine } from '@cornerstonejs/core';
-import { getBrushToolInstances } from './utilities';
+import { getBrushToolInstances } from './getBrushToolInstances';
 export function invalidateBrushCursor(toolGroupId) {
     const toolGroup = getToolGroup(toolGroupId);
     if (toolGroup === undefined) {
@@ -16,8 +15,6 @@ export function invalidateBrushCursor(toolGroupId) {
     if (!viewportsInfoArray.length) {
         return;
     }
-    const { renderingEngineId } = viewportsInfoArray[0];
     const viewportIds = toolGroup.getViewportIds();
-    const renderingEngine = getRenderingEngine(renderingEngineId);
     triggerAnnotationRenderForViewportIds(viewportIds);
 }

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

@@ -1,5 +1,6 @@
 import { state } from '../../stateManagement/annotation';
-import { RectangleROIStartEndThresholdTool, RectangleROIThresholdTool, } from '../../tools';
+import RectangleROIStartEndThresholdTool from '../../tools/segmentation/RectangleROIStartEndThresholdTool';
+import RectangleROIThresholdTool from '../../tools/segmentation/RectangleROIThresholdTool';
 import thresholdVolumeByRange from './thresholdVolumeByRange';
 import getBoundsIJKFromRectangleAnnotations from '../rectangleROITool/getBoundsIJKFromRectangleAnnotations';
 function rectangleROIThresholdVolumeByRange(annotationUIDs, segmentationVolume, thresholdVolumeInformation, options) {
@@ -9,8 +10,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

@@ -1,10 +1,11 @@
 import { getEnabledElement } from '@cornerstonejs/core';
-import * as segmentation from '../../stateManagement/segmentation';
 import { state as annotationState, config as annotationConfig, } from '../../stateManagement/annotation';
 import { jumpToSlice } from '../viewport';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 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) {
     const { data: configurationData } = configuration;
     const enabledElement = getEnabledElement(element);
@@ -13,21 +14,21 @@ export default function segmentContourAction(element, configuration) {
         return;
     }
     const FrameOfReferenceUID = enabledElement.viewport.getFrameOfReferenceUID();
-    const segmentationsList = segmentation.state.getSegmentations();
+    const segmentationsList = getSegmentations();
     const { segmentIndex, segmentationId } = segment;
     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 +38,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);
@@ -76,13 +77,12 @@ export default function segmentContourAction(element, configuration) {
     return newBidirectional;
 }
 export function defaultGetSegment(enabledElement, configuration) {
-    const segmentationsList = segmentation.state.getSegmentations();
+    const segmentationsList = getSegmentations();
     if (!segmentationsList.length) {
         return;
     }
     const segmentationId = configuration.segmentationId || segmentationsList[0].segmentationId;
-    const segmentIndex = configuration.segmentIndex ??
-        segmentation.segmentIndex.getActiveSegmentIndex(segmentationId);
+    const segmentIndex = configuration.segmentIndex ?? getActiveSegmentIndex(segmentationId);
     if (!segmentIndex) {
         return;
     }

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);
         }
     }
 }