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

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

@@ -1,26 +1,37 @@
-import { StackViewport, cache, getEnabledElement, utilities as csUtils, metaData, triggerEvent, eventTarget, } from '@cornerstonejs/core';
+import { StackViewport, cache, getEnabledElement, utilities as csUtils, utilities as coreUtils, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-import { Events } from '../../enums';
 import { addAnnotation, removeAnnotation, getAnnotations, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, } from '../../drawingSvg';
+import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import throttle from '../../utilities/throttle';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
 import { hideElementCursor, resetElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { triggerAnnotationCompleted } from '../../stateManagement/annotation/helpers/state';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import CircleROITool from '../annotation/CircleROITool';
 import { getCanvasCircleCorners, getCanvasCircleRadius, } from '../../utilities/math/circle';
+import { getCalibratedLengthUnitsAndScale, getCalibratedAspect, } from '../../utilities/getCalibratedUnits';
+import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { pointInEllipse } from '../../utilities/math/ellipse';
-import { pointInShapeCallback } from '../../utilities';
+import { roundNumber } from '../../utilities';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
+import cloneDeep from 'lodash.clonedeep';
+import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 const { transformWorldToIndex } = csUtils;
 class CircleROIStartEndThresholdTool extends CircleROITool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            storePointData: false,
             numSlicesToPropagate: 10,
             calculatePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
+            showTextBox: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -45,8 +56,8 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 referencedImageId = csUtils.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
             }
             const spacingInNormal = csUtils.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
-            const newStartIndex = this._getStartSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
-            const endIndex = this._getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 highlighted: true,
@@ -63,13 +74,18 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 },
                 data: {
                     label: '',
-                    startSlice: newStartIndex,
-                    endSlice: endIndex,
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
                     handles: {
                         textBox: {
                             hasMoved: false,
-                            worldPosition: null,
-                            worldBoundingBox: null,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
                         },
                         points: [[...worldPos], [...worldPos]],
                         activeHandleIndex: null,
@@ -77,10 +93,12 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     cachedStats: {
                         pointsInVolume: [],
                         projectionPoints: [],
+                        statistics: [],
                     },
                     labelmapUID: null,
                 },
             };
+            this._computeProjectionPoints(annotation, imageVolume);
             addAnnotation(annotation, element);
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
             this.editData = {
@@ -118,7 +136,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             const targetId = this.getTargetId(enabledElement.viewport);
             const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
             if (this.configuration.calculatePointsInsideVolume) {
-                this._computePointsInsideVolume(annotation, imageVolume, enabledElement);
+                this._computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement);
             }
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
@@ -128,11 +146,11 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
             let renderStatus = false;
             const { viewport } = enabledElement;
-            const annotations = getAnnotations(this.getToolName(), viewport.element);
+            let annotations = getAnnotations(this.getToolName(), viewport.element);
             if (!annotations?.length) {
                 return renderStatus;
             }
-            const sliceIndex = viewport.getCurrentImageIdIndex();
+            annotations = filterAnnotationsWithinSamePlane(annotations, viewport.getCamera());
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),
@@ -141,7 +159,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             for (let i = 0; i < annotations.length; i++) {
                 const annotation = annotations[i];
                 const { annotationUID, data } = annotation;
-                const { startSlice, endSlice } = data;
+                const { startCoordinate, endCoordinate } = data;
                 const { points, activeHandleIndex } = data.handles;
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
@@ -151,16 +169,31 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 const center = canvasCoordinates[0];
                 const radius = getCanvasCircleRadius(canvasCoordinates);
                 const { centerPointRadius } = this.configuration;
-                if (sliceIndex < Math.min(startSlice, endSlice) ||
-                    sliceIndex > Math.max(startSlice, endSlice)) {
+                const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let startCoord = startCoordinate;
+                let endCoord = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                }
+                if (Array.isArray(endCoordinate)) {
+                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                }
+                const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
+                const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = coreUtils.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
                 if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, enabledElement);
                 }
-                const middleSlice = Math.round((startSlice + endSlice) / 2);
+                const middleCoord = coreUtils.roundToPrecision((startCoord + endCoord) / 2);
                 let isMiddleSlice = false;
-                if (sliceIndex === middleSlice) {
+                if (roundedCoord === middleCoord) {
                     isMiddleSlice = true;
                 }
                 if (!viewport.getRenderingEngine()) {
@@ -184,13 +217,18 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     });
                 }
                 let lineWidthToUse = lineWidth;
+                let lineDashToUse = lineDash;
                 if (isMiddleSlice) {
-                    lineWidthToUse = 3;
+                    lineWidthToUse = lineWidth;
+                    lineDashToUse = [];
+                }
+                else {
+                    lineDashToUse = [5, 5];
                 }
                 const circleUID = '0';
                 drawCircleSvg(svgDrawingHelper, annotationUID, circleUID, center, radius, {
                     color,
-                    lineDash,
+                    lineDash: lineDashToUse,
                     lineWidth: lineWidthToUse,
                 });
                 if (centerPointRadius > 0) {
@@ -203,6 +241,43 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     }
                 }
                 renderStatus = true;
+                if (this.configuration.showTextBox == true &&
+                    this.configuration.calculatePointsInsideVolume == true) {
+                    const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+                    if (!options.visibility) {
+                        data.handles.textBox = {
+                            hasMoved: false,
+                            worldPosition: [0, 0, 0],
+                            worldBoundingBox: {
+                                topLeft: [0, 0, 0],
+                                topRight: [0, 0, 0],
+                                bottomLeft: [0, 0, 0],
+                                bottomRight: [0, 0, 0],
+                            },
+                        };
+                        continue;
+                    }
+                    const textLines = this.configuration.getTextLines(data);
+                    if (!textLines || textLines.length === 0) {
+                        continue;
+                    }
+                    let canvasTextBoxCoords;
+                    if (!data.handles.textBox.hasMoved) {
+                        canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCorners);
+                        data.handles.textBox.worldPosition =
+                            viewport.canvasToWorld(canvasTextBoxCoords);
+                    }
+                    const textBoxPosition = viewport.worldToCanvas(data.handles.textBox.worldPosition);
+                    const textBoxUID = '1';
+                    const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotationUID, textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, options);
+                    const { x: left, y: top, width, height } = boundingBox;
+                    data.handles.textBox.worldBoundingBox = {
+                        topLeft: viewport.canvasToWorld([left, top]),
+                        topRight: viewport.canvasToWorld([left + width, top]),
+                        bottomLeft: viewport.canvasToWorld([left, top + height]),
+                        bottomRight: viewport.canvasToWorld([left + width, top + height]),
+                    };
+                }
             }
             return renderStatus;
         };
@@ -212,22 +287,37 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         const { data, metadata } = annotation;
         const { viewPlaneNormal, spacingInNormal } = metadata;
         const { imageData } = imageVolume;
-        const { startSlice, endSlice } = data;
+        const { startCoordinate, endCoordinate } = data;
         const { points } = data.handles;
         const startIJK = transformWorldToIndex(imageData, points[0]);
-        startIJK[2] = startSlice;
-        if (startIJK[2] !== startSlice) {
-            throw new Error('Start slice does not match');
-        }
-        const endIJK = vec3.fromValues(startIJK[0], startIJK[1], endSlice);
+        const endIJK = transformWorldToIndex(imageData, points[0]);
+        const handlesToStart = cloneDeep(points);
         const startWorld = vec3.create();
         imageData.indexToWorldVec3(startIJK, startWorld);
         const endWorld = vec3.create();
         imageData.indexToWorldVec3(endIJK, endWorld);
+        if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 2) {
+            startWorld[2] = startCoordinate;
+            endWorld[2] = endCoordinate;
+            handlesToStart[0][2] = startCoordinate;
+            handlesToStart[1][2] = startCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+            handlesToStart[0][0] = startCoordinate;
+            handlesToStart[1][0] = startCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+            handlesToStart[0][1] = startCoordinate;
+            handlesToStart[1][1] = startCoordinate;
+        }
         const distance = vec3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
         for (let dist = 0; dist < distance; dist += spacingInNormal) {
-            newProjectionPoints.push(points.map((point) => {
+            newProjectionPoints.push(handlesToStart.map((point) => {
                 const newPoint = vec3.create();
                 vec3.scaleAndAdd(newPoint, point, viewPlaneNormal, dist);
                 return Array.from(newPoint);
@@ -235,11 +325,28 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
-        const { viewport } = enabledElement;
+    _computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
+        const { viewport, renderingEngine } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
+        const image = this.getTargetIdImage(targetId, renderingEngine);
+        const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
+        const [topLeftCanvas, bottomRightCanvas] = (getCanvasCircleCorners(canvasCoordinates));
+        const pos1 = viewport.canvasToWorld(topLeftCanvas);
+        const pos2 = viewport.canvasToWorld(bottomRightCanvas);
+        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromTwoPoints(viewPlaneNormal, viewUp, pos1, pos2);
+        const measureInfo = getCalibratedLengthUnitsAndScale(image, data.handles);
+        const aspect = getCalibratedAspect(image);
+        const area = Math.abs(Math.PI *
+            (worldWidth / measureInfo.scale / 2) *
+            (worldHeight / aspect / measureInfo.scale / 2));
+        const modalityUnitOptions = {
+            isPreScaled: isViewportPreScaled(viewport, targetId),
+            isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+        };
+        const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -251,16 +358,21 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
             const worldPos1 = topLeftWorld;
             const worldPos2 = bottomRightWorld;
-            const { dimensions, imageData } = imageVolume;
+            const { dimensions, imageData, voxelManager } = imageVolume;
             const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
-            const worldCenterIndex = transformWorldToIndex(imageData, centerWorld);
+            const worldProjectionPointIndex = transformWorldToIndex(imageData, centerWorld);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
             worldPos1Index[0] = Math.floor(worldPos1Index[0]);
             worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-            worldPos1Index[2] = Math.floor(worldCenterIndex[2]);
+            worldPos1Index[2] = Math.floor(worldPos1Index[2]);
+            worldPos1Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
             worldPos2Index[0] = Math.floor(worldPos2Index[0]);
             worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-            worldPos2Index[2] = Math.floor(worldCenterIndex[2]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
                 const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
@@ -280,61 +392,81 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                     yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
                     zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
                 };
-                const pointsInShape = pointInShapeCallback(imageData, (pointLPS) => pointInEllipse(ellipseObj, pointLPS), null, boundsIJK);
+                const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                    isInObject: (pointLPS) => pointInEllipse(ellipseObj, pointLPS),
+                    boundsIJK,
+                    imageData,
+                    returnPoints: this.configuration.storePointData,
+                });
                 pointsInsideVolume.push(pointsInShape);
             }
         }
+        const stats = this.configuration.statsCalculator.getStatistics();
         data.cachedStats.pointsInVolume = pointsInsideVolume;
+        data.cachedStats.statistics = {
+            Modality: metadata.Modality,
+            area,
+            mean: stats.mean?.value,
+            stdDev: stats.stdDev?.value,
+            max: stats.max?.value,
+            statsArray: stats.array,
+            areaUnits: measureInfo.areaUnits,
+            pixelValueUnits,
+        };
     }
     _calculateCachedStatsTool(annotation, enabledElement) {
         const data = annotation.data;
-        const { viewportId, renderingEngineId, viewport } = enabledElement;
+        const { viewport } = enabledElement;
         const { cachedStats } = data;
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
         annotation.invalidated = false;
-        const eventType = Events.ANNOTATION_MODIFIED;
-        const eventDetail = {
-            annotation,
-            viewportId,
-            renderingEngineId,
-        };
-        triggerEvent(eventTarget, eventType, eventDetail);
+        triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;
     }
-    _getStartSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getStartCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
         const numSlicesToPropagateFromStart = Math.round(numSlicesToPropagate / 2);
         const startPos = vec3.create();
         vec3.scaleAndAdd(startPos, worldPos, viewPlaneNormal, numSlicesToPropagateFromStart * -spacingInNormal);
-        const imageIdIndex = this._getImageIdIndex(imageVolume, startPos, spacingInNormal, viewPlaneNormal);
-        return imageIdIndex;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
     }
-    _getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
-        const numSlicesToPropagateFromStart = Math.round(numSlicesToPropagate / 2);
+        const numSlicesToPropagateToEnd = numSlicesToPropagate - Math.round(numSlicesToPropagate / 2);
         const endPos = vec3.create();
-        vec3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagateFromStart * spacingInNormal);
-        const imageIdIndex = this._getImageIdIndex(imageVolume, endPos, spacingInNormal, viewPlaneNormal);
-        return imageIdIndex;
+        vec3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagateToEnd * spacingInNormal);
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
     }
-    _getImageIdIndex(imageVolume, pos, spacingInNormal, viewPlaneNormal) {
-        const halfSpacingInNormalDirection = spacingInNormal / 2;
-        const { imageIds } = imageVolume;
-        let imageIdIndex;
-        for (let i = 0; i < imageIds.length; i++) {
-            const imageId = imageIds[i];
-            const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
-            const dir = vec3.create();
-            vec3.sub(dir, pos, imagePositionPatient);
-            const dot = vec3.dot(dir, viewPlaneNormal);
-            if (Math.abs(dot) < halfSpacingInNormalDirection) {
-                imageIdIndex = i;
-            }
-        }
-        return imageIdIndex;
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) {
+        const viewplaneNormalAbs = [
+            Math.abs(viewPlaneNormal[0]),
+            Math.abs(viewPlaneNormal[1]),
+            Math.abs(viewPlaneNormal[2]),
+        ];
+        const indexOfDirection = viewplaneNormalAbs.indexOf(Math.max(...viewplaneNormalAbs));
+        return indexOfDirection;
+    }
+    _getCoordinateForViewplaneNormal(pos, viewPlaneNormal) {
+        const indexOfDirection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
+        return pos[indexOfDirection];
+    }
+}
+function defaultGetTextLines(data) {
+    const cachedVolumeStats = data.cachedStats.statistics;
+    const { area, mean, max, stdDev, areaUnits, pixelValueUnits } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
     }
+    const textLines = [];
+    textLines.push(`Area: ${roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
+    return textLines;
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 export default CircleROIStartEndThresholdTool;

package/dist/esm/tools/segmentation/CircleScissorsTool.d.ts

@@ -1,14 +1,14 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
-import { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
 declare class CircleScissorsTool extends BaseTool {
     static toolName: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         segmentIndex: number;
+        segmentationId: string;
         volumeId: string;
         referencedVolumeId: string;
-        imageId: string;
         segmentsLocked: number[];
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];

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

@@ -35,13 +35,13 @@ class CircleScissorsTool extends BaseTool {
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
             const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[type];
@@ -61,7 +61,12 @@ class CircleScissorsTool extends BaseTool {
                 },
                 data: {
                     handles: {
-                        points: [[...worldPos], [...worldPos], [...worldPos], [...worldPos]],
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
                         activeHandleIndex: null,
                     },
                     isDrawing: true,
@@ -82,6 +87,8 @@ class CircleScissorsTool extends BaseTool {
                 newAnnotation: true,
                 hasMoved: false,
                 segmentationRepresentationUID,
+                volumeId: null,
+                referencedVolumeId: null,
             };
             if (isVolumeSegmentation(labelmapData, viewport)) {
                 const { volumeId } = labelmapData;

package/dist/esm/tools/segmentation/PaintFillTool.d.ts

@@ -1,5 +1,5 @@
 import { BaseTool } from '../base';
-import { PublicToolProps, ToolProps, EventTypes } from '../../types';
+import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
 declare class PaintFillTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

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

@@ -4,7 +4,7 @@ import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, } from '../../stateManagement/segmentation';
 import floodFill from '../../utilities/segmentation/floodFill';
-import { getLabelmapImageIdsForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 const { transformWorldToIndex, isEqual } = csUtils;
 class PaintFillTool extends BaseTool {
@@ -20,36 +20,37 @@ class PaintFillTool extends BaseTool {
             const { viewport } = enabledElement;
             const camera = viewport.getCamera();
             const { viewPlaneNormal } = camera;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveRepresentation(viewport.id);
+            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(viewport.id);
             if (!activeSegmentationRepresentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationId, type, segmentationRepresentationUID } = activeSegmentationRepresentation;
+            const { segmentationId, type } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];
             let dimensions;
             let direction;
             let scalarData;
             let index;
+            let voxelManager;
             if (isVolumeSegmentation(labelmapData, viewport)) {
                 const { volumeId } = representationData[type];
                 const segmentation = cache.getVolume(volumeId);
                 ({ dimensions, direction } = segmentation);
-                scalarData = segmentation.getScalarData();
+                voxelManager = segmentation.voxelManager;
                 index = transformWorldToIndex(segmentation.imageData, worldPos);
             }
             else {
-                const currentSegmentationImageId = getLabelmapImageIdsForViewport(viewport.id, segmentationId);
+                const currentSegmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 if (!currentSegmentationImageId) {
                     throw new Error('No active segmentation imageId detected, create one before using scissors tool');
                 }
-                const segmentationImage = cache.getImage(currentSegmentationImageId);
-                scalarData = segmentationImage.getPixelData();
                 const { imageData } = viewport.getImageData();
                 dimensions = imageData.getDimensions();
                 direction = imageData.getDirection();
+                const image = cache.getImage(currentSegmentationImageId);
+                voxelManager = image.voxelManager;
                 index = transformWorldToIndex(imageData, worldPos);
             }
             const fixedDimension = this.getFixedDimension(viewPlaneNormal, direction);
@@ -57,7 +58,7 @@ class PaintFillTool extends BaseTool {
                 console.warn('Oblique paint fill not yet supported');
                 return;
             }
-            const { floodFillGetter, getLabelValue, getScalarDataPositionFromPlane, inPlaneSeedPoint, fixedDimensionValue, } = this.generateHelpers(scalarData, dimensions, index, fixedDimension);
+            const { floodFillGetter, getLabelValue, getScalarDataPositionFromPlane, inPlaneSeedPoint, fixedDimensionValue, } = this.generateHelpers(voxelManager, dimensions, index, fixedDimension);
             if (index[0] < 0 ||
                 index[0] >= dimensions[0] ||
                 index[1] < 0 ||
@@ -73,8 +74,8 @@ class PaintFillTool extends BaseTool {
             const floodFillResult = floodFill(floodFillGetter, inPlaneSeedPoint);
             const { flooded } = floodFillResult;
             flooded.forEach((index) => {
-                const scalarDataPosition = getScalarDataPositionFromPlane(index[0], index[1]);
-                scalarData[scalarDataPosition] = segmentIndex;
+                const scalarDataIndex = getScalarDataPositionFromPlane(index[0], index[1]);
+                voxelManager.setAtIndex(scalarDataIndex, segmentIndex);
             });
             const framesModified = this.getFramesModified(fixedDimension, fixedDimensionValue, floodFillResult);
             triggerSegmentationDataModified(segmentationId, framesModified);
@@ -102,7 +103,7 @@ class PaintFillTool extends BaseTool {
             }
             return framesModified;
         };
-        this.generateHelpers = (scalarData, dimensions, seedIndex3D, fixedDimension = 2) => {
+        this.generateHelpers = (voxelManager, dimensions, seedIndex3D, fixedDimension = 2) => {
             let fixedDimensionValue;
             let inPlaneSeedPoint;
             switch (fixedDimension) {
@@ -122,10 +123,10 @@ class PaintFillTool extends BaseTool {
                     throw new Error(`Invalid fixedDimension: ${fixedDimension}`);
             }
             const getScalarDataPosition = (x, y, z) => {
-                return z * dimensions[1] * dimensions[0] + y * dimensions[0] + x;
+                return voxelManager.toIndex([x, y, z]);
             };
             const getLabelValue = (x, y, z) => {
-                return scalarData[getScalarDataPosition(x, y, z)];
+                return voxelManager.getAtIJK(x, y, z);
             };
             const floodFillGetter = this.generateFloodFillGetter(dimensions, fixedDimension, fixedDimensionValue, getLabelValue);
             const getScalarDataPositionFromPlane = this.generateGetScalarDataPositionFromPlane(getScalarDataPosition, fixedDimension, fixedDimensionValue);