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

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

@@ -1,12 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
-import { RectangleROIStartEndThresholdAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import { vec3 } from 'gl-matrix';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
+import type { RectangleROIStartEndThresholdAnnotation, ROICachedStats } from '../../types/ToolSpecificAnnotationTypes';
 import RectangleROITool from '../annotation/RectangleROITool';
 declare class RectangleROIStartEndThresholdTool extends RectangleROITool {
     static toolName: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         newAnnotation?: boolean;
@@ -30,18 +31,24 @@ declare class RectangleROIStartEndThresholdTool extends RectangleROITool {
         };
         data: {
             label: string;
-            startSlice: number;
-            endSlice: number;
+            startCoordinate: number;
+            endCoordinate: number;
             cachedStats: {
                 pointsInVolume: any[];
                 projectionPoints: any[];
                 projectionPointsImageIds: any[];
+                statistics: ROICachedStats;
             };
             handles: {
                 textBox: {
                     hasMoved: boolean;
-                    worldPosition: any;
-                    worldBoundingBox: any;
+                    worldPosition: Types.Point3;
+                    worldBoundingBox: {
+                        topLeft: Types.Point3;
+                        topRight: Types.Point3;
+                        bottomLeft: Types.Point3;
+                        bottomRight: Types.Point3;
+                    };
                 };
                 points: Types.Point3[];
                 activeHandleIndex: any;
@@ -51,9 +58,12 @@ declare class RectangleROIStartEndThresholdTool extends RectangleROITool {
     };
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _computeProjectionPoints(annotation: RectangleROIStartEndThresholdAnnotation, imageVolume: Types.IImageVolume): void;
-    _computePointsInsideVolume(annotation: any, imageVolume: any, enabledElement: any): void;
+    _computePointsInsideVolume(annotation: any, targetId: any, imageVolume: any, enabledElement: any): void;
     _calculateCachedStatsTool(annotation: any, enabledElement: any): any;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _getEndSliceIndex(imageVolume: Types.IImageVolume, worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getStartCoordinate(worldPos: Types.Point3, viewPlaneNormal: Types.Point3): number | undefined;
+    _getEndCoordinate(worldPos: Types.Point3, spacingInNormal: number, viewPlaneNormal: Types.Point3): number | undefined;
+    _getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal: Types.Point3): number;
+    _getCoordinateForViewplaneNormal(pos: vec3 | number, viewPlaneNormal: Types.Point3): number | undefined;
 }
 export default RectangleROIStartEndThresholdTool;

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

@@ -1,23 +1,32 @@
-import { getEnabledElement, cache, StackViewport, metaData, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElement, cache, StackViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { vec3 } from 'gl-matrix';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
-import { triggerAnnotationModified } from '../../stateManagement/annotation/helpers/state';
-import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawRect as drawRectSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import throttle from '../../utilities/throttle';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
 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 RectangleROITool from '../annotation/RectangleROITool';
-import { pointInShapeCallback } from '../../utilities/';
+import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
+import { filterAnnotationsWithinSamePlane } from '../../utilities/planar';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 const { transformWorldToIndex } = csUtils;
 class RectangleROIStartEndThresholdTool extends RectangleROITool {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
+            storePointData: false,
             numSlicesToPropagate: 10,
             computePointsInsideVolume: false,
+            getTextLines: defaultGetTextLines,
+            statsCalculator: BasicStatsCalculator,
+            showTextBox: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -40,12 +49,9 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 imageVolume = cache.getVolume(volumeId);
                 referencedImageId = csUtils.getClosestImageId(imageVolume, worldPos, viewPlaneNormal);
             }
-            if (!referencedImageId) {
-                throw new Error('This tool does not work on non-acquisition planes');
-            }
-            const startIndex = viewport.getCurrentImageIdIndex();
             const spacingInNormal = csUtils.getSpacingInNormalDirection(imageVolume, viewPlaneNormal);
-            const endIndex = this._getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal);
+            const startCoord = this._getStartCoordinate(worldPos, viewPlaneNormal);
+            const endCoord = this._getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 highlighted: true,
@@ -62,18 +68,24 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 },
                 data: {
                     label: '',
-                    startSlice: startIndex,
-                    endSlice: endIndex,
+                    startCoordinate: startCoord,
+                    endCoordinate: endCoord,
                     cachedStats: {
                         pointsInVolume: [],
                         projectionPoints: [],
                         projectionPointsImageIds: [referencedImageId],
+                        statistics: [],
                     },
                     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],
@@ -124,7 +136,7 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             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, targetId, imageVolume, enabledElement);
             }
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
@@ -134,11 +146,11 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         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(),
@@ -147,22 +159,37 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             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;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
                 styleSpecifier.annotationUID = annotationUID;
                 const lineWidth = this.getStyle('lineWidth', styleSpecifier, annotation);
                 const lineDash = this.getStyle('lineDash', styleSpecifier, annotation);
                 const color = this.getStyle('color', styleSpecifier, annotation);
-                if (sliceIndex < Math.min(startSlice, endSlice) ||
-                    sliceIndex > Math.max(startSlice, endSlice)) {
+                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 = csUtils.roundToPrecision(startCoord);
+                const roundedEndCoord = csUtils.roundToPrecision(endCoord);
+                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCoord = csUtils.roundToPrecision(coord);
+                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
+                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
                     continue;
                 }
                 if (annotation.invalidated) {
                     this._throttledCalculateCachedStats(annotation, enabledElement);
                 }
                 let firstOrLastSlice = false;
-                if (sliceIndex === startSlice || sliceIndex === endSlice) {
+                if (roundedCoord === roundedStartCoord ||
+                    roundedCoord === roundedEndCoord) {
                     firstOrLastSlice = true;
                 }
                 if (!viewport.getRenderingEngine()) {
@@ -196,6 +223,42 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                     lineWidth,
                 });
                 renderStatus = true;
+                if (this.configuration.showTextBox &&
+                    this.configuration.calculatePointsInsideVolume) {
+                    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;
+                    }
+                    if (!data.handles.textBox.hasMoved) {
+                        const canvasTextBoxCoords = getTextBoxCoordsCanvas(canvasCoordinates);
+                        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;
         };
@@ -205,17 +268,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         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]);
-        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 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;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 0) {
+            startWorld[0] = startCoordinate;
+            endWorld[0] = endCoordinate;
+        }
+        else if (this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal) == 1) {
+            startWorld[1] = startCoordinate;
+            endWorld[1] = endCoordinate;
+        }
         const distance = vec3.distance(startWorld, endWorld);
         const newProjectionPoints = [];
         for (let dist = 0; dist < distance; dist += spacingInNormal) {
@@ -226,34 +298,45 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
             }));
         }
         data.cachedStats.projectionPoints = newProjectionPoints;
-        const projectionPointsImageIds = [];
-        for (const RectanglePoints of newProjectionPoints) {
-            const imageId = csUtils.getClosestImageId(imageVolume, RectanglePoints[0], viewPlaneNormal);
-            projectionPointsImageIds.push(imageId);
-        }
-        data.cachedStats.projectionPointsImageIds = projectionPointsImageIds;
     }
-    _computePointsInsideVolume(annotation, imageVolume, enabledElement) {
-        const { data } = annotation;
+    _computePointsInsideVolume(annotation, targetId, imageVolume, 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 worldPos1 = data.handles.points[0];
+        const worldPos2 = data.handles.points[3];
+        const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+        const measureInfo = getCalibratedLengthUnitsAndScale(image, data.habdles);
+        const area = Math.abs(worldWidth * worldHeight) /
+            (measureInfo.scale * measureInfo.scale);
+        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;
             }
             const projectionPoint = projectionPoints[i][0];
-            const worldPos1 = data.handles.points[0];
-            const worldPos2 = data.handles.points[3];
-            const { dimensions, imageData } = imageVolume;
+            const { dimensions, imageData, voxelManager } = imageVolume;
             const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
             const worldProjectionPointIndex = transformWorldToIndex(imageData, projectionPoint);
+            const indexOfProjection = this._getIndexOfCoordinatesForViewplaneNormal(viewPlaneNormal);
             worldPos1Index[0] = Math.floor(worldPos1Index[0]);
             worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-            worldPos1Index[2] = Math.floor(worldProjectionPointIndex[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(worldProjectionPointIndex[2]);
+            worldPos2Index[2] = Math.floor(worldPos2Index[2]);
+            worldPos2Index[indexOfProjection] =
+                worldProjectionPointIndex[indexOfProjection];
             if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
                 this.isHandleOutsideImage = false;
                 const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
@@ -267,11 +350,26 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                     [jMin, jMax],
                     [kMin, kMax],
                 ];
-                const pointsInShape = pointInShapeCallback(imageData, () => true, null, boundsIJK);
+                const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                    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;
@@ -284,25 +382,44 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;
     }
-    _getEndSliceIndex(imageVolume, worldPos, spacingInNormal, viewPlaneNormal) {
+    _getStartCoordinate(worldPos, viewPlaneNormal) {
+        const startPos = worldPos;
+        const startCoord = this._getCoordinateForViewplaneNormal(startPos, viewPlaneNormal);
+        return startCoord;
+    }
+    _getEndCoordinate(worldPos, spacingInNormal, viewPlaneNormal) {
         const numSlicesToPropagate = this.configuration.numSlicesToPropagate;
         const endPos = vec3.create();
         vec3.scaleAndAdd(endPos, worldPos, viewPlaneNormal, numSlicesToPropagate * spacingInNormal);
-        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, endPos, imagePositionPatient);
-            const dot = vec3.dot(dir, viewPlaneNormal);
-            if (Math.abs(dot) < halfSpacingInNormalDirection) {
-                imageIdIndex = i;
-            }
-        }
-        return imageIdIndex;
+        const endCoord = this._getCoordinateForViewplaneNormal(endPos, viewPlaneNormal);
+        return endCoord;
+    }
+    _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: ${csUtils.roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${csUtils.roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${csUtils.roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${csUtils.roundNumber(stdDev)} ${pixelValueUnits}`);
+    return textLines;
 }
 RectangleROIStartEndThresholdTool.toolName = 'RectangleROIStartEndThreshold';
 export default RectangleROIStartEndThresholdTool;

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

@@ -1,11 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
+import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper, Annotation } from '../../types';
 import RectangleROITool from '../annotation/RectangleROITool';
 declare class RectangleROIThresholdTool extends RectangleROITool {
     static toolName: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         newAnnotation?: boolean;

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

@@ -1,17 +1,18 @@
 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 RectangleScissorsTool extends BaseTool {
     static toolName: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
         volumeId: string;
         referencedVolumeId: string;
         imageId: string;
-        annotation: any;
+        annotation: Annotation;
         segmentationId: string;
         segmentIndex: number;
         segmentsLocked: number[];
+        segmentationRepresentationUID: string;
         segmentColor: [number, number, number, number];
         viewportIdsToRender: string[];
         handleIndex?: number;

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

@@ -1,4 +1,4 @@
-import { cache, getEnabledElement } from '@cornerstonejs/core';
+import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { fillInsideRectangle } from './strategies/fillRectangle';
 import { eraseInsideRectangle } from './strategies/eraseRectangle';
@@ -8,7 +8,7 @@ import { drawRect as drawRectSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 class RectangleScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -35,13 +35,13 @@ class RectangleScissorsTool 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 { segmentationRepresentationUID, segmentationId } = 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[SegmentationRepresentations.Labelmap];
@@ -81,6 +81,9 @@ class RectangleScissorsTool extends BaseTool {
                 newAnnotation: true,
                 hasMoved: false,
                 segmentationRepresentationUID,
+                volumeId: null,
+                referencedVolumeId: null,
+                imageId: null,
             };
             if (isVolumeSegmentation(labelmapData, viewport)) {
                 const { volumeId } = labelmapData;

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
-import { PublicToolProps, ToolProps, EventTypes } from '../../types';
-import { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
+import type { PublicToolProps, ToolProps, EventTypes } from '../../types';
+import type { SegmentationRepresentation } from '../../types/SegmentationStateTypes';
 declare class SegmentSelectTool extends BaseTool {
     static toolName: any;
     private hoverTimer;

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

@@ -2,11 +2,11 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import { triggerSegmentationModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getActiveRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
+import { getActiveSegmentationRepresentation } from '../../stateManagement/segmentation/activeSegmentation';
 import RepresentationTypes from '../../enums/SegmentationRepresentations';
 import { setActiveSegmentIndex } from '../../stateManagement/segmentation/segmentIndex';
 import { getHoveredContourSegmentationAnnotation, getSegmentIndexAtLabelmapBorder, getSegmentIndexAtWorldPoint, } from '../../utilities/segmentation';
-import { state } from '../../store';
+import { state } from '../../store/state';
 import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
 class SegmentSelectTool extends BaseTool {
     static { this.SelectMode = {
@@ -54,7 +54,7 @@ class SegmentSelectTool extends BaseTool {
             return;
         }
         const { viewport } = enabledElement;
-        const activeSegmentationReps = getActiveRepresentation(viewport.id);
+        const activeSegmentationReps = getActiveSegmentationRepresentation(viewport.id);
         if (!activeSegmentationReps) {
             return;
         }

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

@@ -1,13 +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 SphereScissorsTool extends BaseTool {
     static toolName: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         segmentIndex: number;
         segmentsLocked: number[];
         segmentationRepresentationUID: string;
+        segmentationId: string;
         volumeId: string;
         referencedVolumeId: string;
         imageId: string;

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

@@ -7,7 +7,7 @@ import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { config as segmentationConfig, segmentLocking, segmentIndex as segmentIndexController, activeSegmentation, } from '../../stateManagement/segmentation';
-import { getSegmentation, } from '../../stateManagement/segmentation/segmentationState';
+import { getSegmentation } from '../../stateManagement/segmentation/segmentationState';
 import { isVolumeSegmentation } from './strategies/utils/stackVolumeCheck';
 class SphereScissorsTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -35,13 +35,13 @@ class SphereScissorsTool 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 } = activeSegmentationRepresentation;
             const segmentIndex = segmentIndexController.getActiveSegmentIndex(segmentationId);
-            const segmentsLocked = segmentLocking.getLockedSegments(segmentationId);
+            const segmentsLocked = segmentLocking.getLockedSegmentIndices(segmentationId);
             const segmentColor = segmentationConfig.color.getSegmentIndexColor(segmentationRepresentationUID, segmentIndex);
             this.isDrawing = true;
             const annotation = {
@@ -56,7 +56,12 @@ class SphereScissorsTool extends BaseTool {
                 data: {
                     invalidated: true,
                     handles: {
-                        points: [[...worldPos], [...worldPos], [...worldPos], [...worldPos]],
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
                         activeHandleIndex: null,
                     },
                     cachedStats: {},
@@ -78,6 +83,9 @@ class SphereScissorsTool extends BaseTool {
                 movingTextBox: false,
                 newAnnotation: true,
                 hasMoved: false,
+                volumeId: null,
+                referencedVolumeId: null,
+                imageId: null,
             };
             const { representationData } = getSegmentation(segmentationId);
             const labelmapData = representationData[SegmentationRepresentations.Labelmap];

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -1,18 +1,17 @@
 import type { Types } from '@cornerstonejs/core';
-import { utilities as csUtils } from '@cornerstonejs/core';
 import { StrategyCallbacks } from '../../../enums';
 import type { LabelmapToolOperationDataAny } from '../../../types/LabelmapToolOperationData';
-import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export type InitializedOperationData = LabelmapToolOperationDataAny & {
     operationName?: string;
     enabledElement: Types.IEnabledElement;
     centerIJK?: Types.Point3;
     centerWorld: Types.Point3;
     viewport: Types.IViewport;
-    imageVoxelManager: csUtils.VoxelManager<number> | csUtils.VoxelManager<Types.RGB>;
-    segmentationVoxelManager: csUtils.VoxelManager<number>;
+    imageVoxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+    segmentationVoxelManager: Types.IVoxelManager<number>;
     segmentationImageData: vtkImageData;
-    previewVoxelManager: csUtils.VoxelManager<number>;
+    previewVoxelManager: Types.IVoxelManager<number>;
     previewSegmentIndex?: number;
     brushStrategy: BrushStrategy;
     configuration?: Record<string, any>;