@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

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

@@ -1,26 +1,36 @@
-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 { 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 +55,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 +73,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 +92,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 = {
@@ -92,7 +109,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this._endCallback = (evt) => {
@@ -118,9 +135,9 @@ 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(enabledElement.renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
                 triggerAnnotationCompleted(annotation);
             }
@@ -128,11 +145,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 +158,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,18 +168,38 @@ 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)) {
-                    continue;
+                const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
+                const focalPoint = viewport.getCamera().focalPoint;
+                const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
+                let tempStartCoordinate = startCoordinate;
+                let tempEndCoordinate = endCoordinate;
+                if (Array.isArray(startCoordinate)) {
+                    tempStartCoordinate = this._getCoordinateForViewplaneNormal(tempStartCoordinate, viewplaneNormal);
+                    data.startCoordinate = tempStartCoordinate;
                 }
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                if (Array.isArray(endCoordinate)) {
+                    tempEndCoordinate = this._getCoordinateForViewplaneNormal(tempEndCoordinate, viewplaneNormal);
+                    data.endCoordinate = tempEndCoordinate;
+                }
+                const roundedStartCoordinate = coreUtils.roundToPrecision(data.startCoordinate);
+                const roundedEndCoordinate = coreUtils.roundToPrecision(data.endCoordinate);
+                const cameraCoordinate = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCameraCoordinate = coreUtils.roundToPrecision(cameraCoordinate);
+                if (roundedCameraCoordinate <
+                    Math.min(roundedStartCoordinate, roundedEndCoordinate) ||
+                    roundedCameraCoordinate >
+                        Math.max(roundedStartCoordinate, roundedEndCoordinate)) {
+                    continue;
                 }
-                const middleSlice = Math.round((startSlice + endSlice) / 2);
+                const middleCoordinate = coreUtils.roundToPrecision((data.startCoordinate + data.endCoordinate) / 2);
                 let isMiddleSlice = false;
-                if (sliceIndex === middleSlice) {
+                if (roundedCameraCoordinate === middleCoordinate) {
                     isMiddleSlice = true;
                 }
+                data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = middleCoordinate;
+                if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                }
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
@@ -171,7 +208,7 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 if (!isAnnotationVisible(annotationUID)) {
                     continue;
                 }
-                if (!isAnnotationLocked(annotation) &&
+                if (!isAnnotationLocked(annotationUID) &&
                     !this.editData &&
                     activeHandleIndex !== null &&
                     isMiddleSlice) {
@@ -184,13 +221,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 +245,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 +291,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 +329,28 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
+    _computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement) {
+        const { data, metadata } = annotation;
+        const { viewPlaneNormal, viewUp } = metadata;
         const { viewport } = enabledElement;
         const projectionPoints = data.cachedStats.projectionPoints;
         const pointsInsideVolume = [[]];
+        const image = this.getTargetImageData(targetId);
+        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 modalityUnit = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
         for (let i = 0; i < projectionPoints.length; i++) {
             if (!imageVolume) {
                 continue;
@@ -251,16 +362,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,62 +396,84 @@ 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,
+            areaUnit: measureInfo.areaUnit,
+            modalityUnit,
+        };
     }
     _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);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement);
+        }
         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, areaUnit, modalityUnit } = cachedVolumeStats;
+    if (mean === undefined) {
+        return;
     }
+    const textLines = [];
+    textLines.push(`Area: ${csUtils.roundNumber(area)} ${areaUnit}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${modalityUnit}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${modalityUnit}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${modalityUnit}`);
+    return textLines;
 }
 CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 export default CircleROIStartEndThresholdTool;
-//# sourceMappingURL=CircleROIStartEndThresholdTool.js.map

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

@@ -0,0 +1,32 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+declare class CircleScissorsTool extends BaseTool {
+    static toolName: any;
+    editData: {
+        annotation: Annotation;
+        segmentIndex: number;
+        segmentationId: string;
+        volumeId: string;
+        referencedVolumeId: string;
+        segmentsLocked: number[];
+        segmentColor: [number, number, number, number];
+        viewportIdsToRender: string[];
+        handleIndex?: number;
+        movingTextBox: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+        imageId: string;
+        centerCanvas?: Array<number>;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    _dragCallback: (evt: EventTypes.InteractionEventType) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _activateDraw: (element: any) => void;
+    _deactivateDraw: (element: any) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+}
+export default CircleScissorsTool;

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

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement } from '@cornerstonejs/core';
+import { BaseVolumeViewport, cache, getEnabledElement, } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideCircle } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
@@ -7,8 +7,7 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { segmentLocking, activeSegmentation, segmentIndex as segmentIndexController, config as segmentationConfig, } from '../../stateManagement/segmentation';
-import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
-import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
+import { getCurrentLabelmapImageIdForViewport, getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
 class CircleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -31,21 +30,20 @@ class CircleScissorsTool extends BaseTool {
             const worldPos = currentPoints.world;
             const canvasPos = currentPoints.canvas;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const toolGroupId = this.toolGroupId;
-            const activeSegmentationRepresentation = activeSegmentation.getActiveSegmentationRepresentation(toolGroupId);
-            if (!activeSegmentationRepresentation) {
+            const activeLabelmapSegmentation = activeSegmentation.getActiveSegmentation(viewport.id);
+            if (!activeLabelmapSegmentation) {
                 throw new Error('No active segmentation detected, create one before using scissors tool');
             }
-            const { segmentationRepresentationUID, segmentationId, type } = activeSegmentationRepresentation;
+            const { segmentationId } = activeLabelmapSegmentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
-            const segmentColor = segmentationConfig.color.getColorForSegmentIndex(toolGroupId, segmentationRepresentationUID, segmentIndex);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
+            const segmentColor = segmentationConfig.color.getSegmentIndexColor(viewport.id, segmentationId, segmentIndex);
             const { representationData } = getSegmentation(segmentationId);
-            const labelmapData = representationData[type];
+            const labelmapData = representationData.Labelmap;
             if (!labelmapData) {
                 throw new Error('No labelmap data found for the active segmentation, create one before using scissors tool');
             }
@@ -62,7 +60,12 @@ class CircleScissorsTool extends BaseTool {
                 },
                 data: {
                     handles: {
-                        points: [[...worldPos], [...worldPos], [...worldPos], [...worldPos]],
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
                         activeHandleIndex: null,
                     },
                     isDrawing: true,
@@ -82,9 +85,11 @@ class CircleScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
-                segmentationRepresentationUID,
+                volumeId: null,
+                referencedVolumeId: null,
+                imageId: null,
             };
-            if (isVolumeSegmentation(labelmapData, viewport)) {
+            if (viewport instanceof BaseVolumeViewport) {
                 const { volumeId } = labelmapData;
                 const segmentation = cache.getVolume(volumeId);
                 this.editData = {
@@ -94,16 +99,16 @@ class CircleScissorsTool extends BaseTool {
                 };
             }
             else {
-                const { imageIdReferenceMap } = labelmapData;
+                const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
                 this.editData = {
                     ...this.editData,
-                    imageIdReferenceMap,
+                    imageId: segmentationImageId,
                 };
             }
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return true;
         };
         this._dragCallback = (evt) => {
@@ -141,7 +146,7 @@ class CircleScissorsTool extends BaseTool {
             ];
             annotation.invalidated = true;
             this.editData.hasMoved = true;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._endCallback = (evt) => {
             const eventDetail = evt.detail;
@@ -224,4 +229,3 @@ class CircleScissorsTool extends BaseTool {
 }
 CircleScissorsTool.toolName = 'CircleScissor';
 export default CircleScissorsTool;
-//# sourceMappingURL=CircleScissorsTool.js.map

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

@@ -0,0 +1,13 @@
+import { BaseTool } from '../base';
+import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
+declare class PaintFillTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    private getFramesModified;
+    private generateHelpers;
+    private getFixedDimension;
+    private generateFloodFillGetter;
+    private generateGetScalarDataPositionFromPlane;
+}
+export default PaintFillTool;