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

package/dist/esm/tools/annotation/PlanarFreehandROITool.js

@@ -17,13 +17,12 @@ import { triggerAnnotationModified } from '../../stateManagement/annotation/help
 import { drawLinkedTextBox } from '../../drawingSvg';
 import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import { getLineSegmentIntersectionsCoordinates } from '../../utilities/math/polyline';
-import pointInShapeCallback from '../../utilities/pointInShapeCallback';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
-import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 import calculatePerimeter from '../../utilities/contours/calculatePerimeter';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 import { KeyboardBindings, ChangeTypes } from '../../enums';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 const { pointCanProjectOnLine } = polyline;
 const { EPSILON } = CONSTANTS;
 const PARALLEL_THRESHOLD = 1 - EPSILON;
@@ -31,6 +30,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            storePointData: false,
             shadow: true,
             preventHandleOutsideImage: false,
             contourHoleAdditionModifierKey: KeyboardBindings.Shift,
@@ -144,45 +144,12 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                 }
                 const { imageData, metadata } = image;
                 const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-                const canvasPoint = canvasCoordinates[0];
-                const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
-                const deltaXPoint = viewport.canvasToWorld([
-                    canvasPoint[0] + 1,
-                    canvasPoint[1],
-                ]);
-                const deltaYPoint = viewport.canvasToWorld([
-                    canvasPoint[0],
-                    canvasPoint[1] + 1,
-                ]);
-                const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
-                const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
-                const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
-                worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-                worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-                worldPosIndex[2] = Math.floor(worldPosIndex[2]);
-                let iMin = worldPosIndex[0];
-                let iMax = worldPosIndex[0];
-                let jMin = worldPosIndex[1];
-                let jMax = worldPosIndex[1];
-                let kMin = worldPosIndex[2];
-                let kMax = worldPosIndex[2];
-                for (let j = 1; j < points.length; j++) {
-                    const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[j]);
-                    worldPosIndex[0] = Math.floor(worldPosIndex[0]);
-                    worldPosIndex[1] = Math.floor(worldPosIndex[1]);
-                    worldPosIndex[2] = Math.floor(worldPosIndex[2]);
-                    iMin = Math.min(iMin, worldPosIndex[0]);
-                    iMax = Math.max(iMax, worldPosIndex[0]);
-                    jMin = Math.min(jMin, worldPosIndex[1]);
-                    jMax = Math.max(jMax, worldPosIndex[1]);
-                    kMin = Math.min(kMin, worldPosIndex[2]);
-                    kMax = Math.max(kMax, worldPosIndex[2]);
-                }
-                const worldPosIndex2 = csUtils.transformWorldToIndex(imageData, points[1]);
-                worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
-                worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
-                worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
-                const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, () => {
+                const modalityUnitOptions = {
+                    isPreScaled: isViewportPreScaled(viewport, targetId),
+                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                };
+                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const calibratedScale = getCalibratedLengthUnitsAndScale(image, () => {
                     const polyline = data.contour.polyline;
                     const numPoints = polyline.length;
                     const projectedPolyline = new Array(numPoints);
@@ -190,10 +157,7 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                         projectedPolyline[i] = viewport.worldToCanvas(polyline[i]);
                     }
                     const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(projectedPolyline);
-                    const topLeftBBWorld = viewport.canvasToWorld([
-                        canvasMinX,
-                        canvasMinY,
-                    ]);
+                    const topLeftBBWorld = viewport.canvasToWorld([canvasMinX, canvasMinY]);
                     const topLeftBBIndex = csUtils.transformWorldToIndex(imageData, topLeftBBWorld);
                     const bottomRightBBWorld = viewport.canvasToWorld([
                         canvasMaxX,
@@ -202,71 +166,29 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
                     const bottomRightBBIndex = csUtils.transformWorldToIndex(imageData, bottomRightBBWorld);
                     return [topLeftBBIndex, bottomRightBBIndex];
                 });
-                let area = polyline.getArea(canvasCoordinates) / scale / scale;
-                area *= deltaInX * deltaInY;
-                const iDelta = 0.01 * (iMax - iMin);
-                const jDelta = 0.01 * (jMax - jMin);
-                const kDelta = 0.01 * (kMax - kMin);
-                iMin = Math.floor(iMin - iDelta);
-                iMax = Math.ceil(iMax + iDelta);
-                jMin = Math.floor(jMin - jDelta);
-                jMax = Math.ceil(jMax + jDelta);
-                kMin = Math.floor(kMin - kDelta);
-                kMax = Math.ceil(kMax + kDelta);
-                const boundsIJK = [
-                    [iMin, iMax],
-                    [jMin, jMax],
-                    [kMin, kMax],
-                ];
-                const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
-                const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
-                let curRow = 0;
-                let intersections = [];
-                let intersectionCounter = 0;
-                const pointsInShape = pointInShapeCallback(imageData, (pointLPS, pointIJK) => {
-                    let result = true;
-                    const point = viewport.worldToCanvas(pointLPS);
-                    if (point[1] != curRow) {
-                        intersectionCounter = 0;
-                        curRow = point[1];
-                        intersections = getLineSegmentIntersectionsCoordinates(canvasCoordinates, point, [canvasPosEnd[0], point[1]]);
-                        intersections.sort((function (index) {
-                            return function (a, b) {
-                                return a[index] === b[index]
-                                    ? 0
-                                    : a[index] < b[index]
-                                        ? -1
-                                        : 1;
-                            };
-                        })(0));
-                    }
-                    if (intersections.length && point[0] > intersections[0][0]) {
-                        intersections.shift();
-                        intersectionCounter++;
-                    }
-                    if (intersectionCounter % 2 === 0) {
-                        result = false;
-                    }
-                    return result;
-                }, this.configuration.statsCalculator.statsCallback, boundsIJK);
-                const pixelUnitsOptions = {
-                    isPreScaled: isViewportPreScaled(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
-                const stats = this.configuration.statsCalculator.getStatistics();
-                cachedStats[targetId] = {
-                    Modality: metadata.Modality,
-                    area,
-                    perimeter: calculatePerimeter(canvasCoordinates, closed),
-                    mean: stats.mean?.value,
-                    max: stats.max?.value,
-                    stdDev: stats.stdDev?.value,
-                    statsArray: stats.array,
-                    pointsInShape: pointsInShape,
-                    areaUnits,
-                    pixelValueUnits,
-                };
+                if (closed) {
+                    this.updateClosedCachedStats({
+                        targetId,
+                        viewport,
+                        canvasCoordinates,
+                        points,
+                        imageData,
+                        metadata,
+                        cachedStats,
+                        pixelValueUnits,
+                        calibratedScale,
+                    });
+                }
+                else {
+                    this.updateOpenCachedStats({
+                        metadata,
+                        canvasCoordinates,
+                        targetId,
+                        cachedStats,
+                        pixelValueUnits,
+                        calibratedScale,
+                    });
+                }
             }
             triggerAnnotationModified(annotation, enabledElement.viewport.element, ChangeTypes.StatsUpdated);
             annotation.invalidated = false;
@@ -459,10 +381,127 @@ class PlanarFreehandROITool extends ContourSegmentationBaseTool {
             }
         }
     }
+    updateClosedCachedStats({ viewport, points, imageData, metadata, cachedStats, targetId, pixelValueUnits, canvasCoordinates, calibratedScale, }) {
+        const { scale, areaUnits, units } = calibratedScale;
+        const { voxelManager } = viewport.getImageData();
+        const canvasPoint = canvasCoordinates[0];
+        const originalWorldPoint = viewport.canvasToWorld(canvasPoint);
+        const deltaXPoint = viewport.canvasToWorld([
+            canvasPoint[0] + 1,
+            canvasPoint[1],
+        ]);
+        const deltaYPoint = viewport.canvasToWorld([
+            canvasPoint[0],
+            canvasPoint[1] + 1,
+        ]);
+        const deltaInX = vec3.distance(originalWorldPoint, deltaXPoint);
+        const deltaInY = vec3.distance(originalWorldPoint, deltaYPoint);
+        const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[0]);
+        worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+        worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+        worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+        let iMin = worldPosIndex[0];
+        let iMax = worldPosIndex[0];
+        let jMin = worldPosIndex[1];
+        let jMax = worldPosIndex[1];
+        let kMin = worldPosIndex[2];
+        let kMax = worldPosIndex[2];
+        for (let j = 1; j < points.length; j++) {
+            const worldPosIndex = csUtils.transformWorldToIndex(imageData, points[j]);
+            worldPosIndex[0] = Math.floor(worldPosIndex[0]);
+            worldPosIndex[1] = Math.floor(worldPosIndex[1]);
+            worldPosIndex[2] = Math.floor(worldPosIndex[2]);
+            iMin = Math.min(iMin, worldPosIndex[0]);
+            iMax = Math.max(iMax, worldPosIndex[0]);
+            jMin = Math.min(jMin, worldPosIndex[1]);
+            jMax = Math.max(jMax, worldPosIndex[1]);
+            kMin = Math.min(kMin, worldPosIndex[2]);
+            kMax = Math.max(kMax, worldPosIndex[2]);
+        }
+        const worldPosIndex2 = csUtils.transformWorldToIndex(imageData, points[1]);
+        worldPosIndex2[0] = Math.floor(worldPosIndex2[0]);
+        worldPosIndex2[1] = Math.floor(worldPosIndex2[1]);
+        worldPosIndex2[2] = Math.floor(worldPosIndex2[2]);
+        let area = polyline.getArea(canvasCoordinates) / scale / scale;
+        area *= deltaInX * deltaInY;
+        const iDelta = 0.01 * (iMax - iMin);
+        const jDelta = 0.01 * (jMax - jMin);
+        const kDelta = 0.01 * (kMax - kMin);
+        iMin = Math.floor(iMin - iDelta);
+        iMax = Math.ceil(iMax + iDelta);
+        jMin = Math.floor(jMin - jDelta);
+        jMax = Math.ceil(jMax + jDelta);
+        kMin = Math.floor(kMin - kDelta);
+        kMax = Math.ceil(kMax + kDelta);
+        const boundsIJK = [
+            [iMin, iMax],
+            [jMin, jMax],
+            [kMin, kMax],
+        ];
+        const worldPosEnd = imageData.indexToWorld([iMax, jMax, kMax]);
+        const canvasPosEnd = viewport.worldToCanvas(worldPosEnd);
+        let curRow = 0;
+        let intersections = [];
+        let intersectionCounter = 0;
+        const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+            imageData,
+            isInObject: (pointLPS, _pointIJK) => {
+                let result = true;
+                const point = viewport.worldToCanvas(pointLPS);
+                if (point[1] != curRow) {
+                    intersectionCounter = 0;
+                    curRow = point[1];
+                    intersections = getLineSegmentIntersectionsCoordinates(canvasCoordinates, point, [canvasPosEnd[0], point[1]]);
+                    intersections.sort((function (index) {
+                        return function (a, b) {
+                            return a[index] === b[index]
+                                ? 0
+                                : a[index] < b[index]
+                                    ? -1
+                                    : 1;
+                        };
+                    })(0));
+                }
+                if (intersections.length && point[0] > intersections[0][0]) {
+                    intersections.shift();
+                    intersectionCounter++;
+                }
+                if (intersectionCounter % 2 === 0) {
+                    result = false;
+                }
+                return result;
+            },
+            boundsIJK,
+            returnPoints: this.configuration.storePointData,
+        });
+        const stats = this.configuration.statsCalculator.getStatistics();
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            area,
+            perimeter: calculatePerimeter(canvasCoordinates, closed) / scale,
+            mean: stats.mean?.value,
+            max: stats.max?.value,
+            stdDev: stats.stdDev?.value,
+            statsArray: stats.array,
+            pointsInShape: pointsInShape,
+            areaUnits,
+            pixelValueUnits,
+            lengthUnits: units,
+        };
+    }
+    updateOpenCachedStats({ targetId, metadata, canvasCoordinates, cachedStats, pixelValueUnits, calibratedScale, }) {
+        const { scale, units } = calibratedScale;
+        cachedStats[targetId] = {
+            Modality: metadata.Modality,
+            length: calculatePerimeter(canvasCoordinates, false) / scale,
+            pixelValueUnits,
+            getPixelValueUnitunit: units,
+        };
+    }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, stdDev, perimeter, max, isEmptyArea, areaUnits, pixelValueUnits, } = cachedVolumeStats || {};
+    const { area, mean, stdDev, length, perimeter, max, isEmptyArea, lengthUnits, areaUnits, pixelValueUnits, } = cachedVolumeStats || {};
     const textLines = [];
     if (area) {
         const areaLine = isEmptyArea
@@ -473,14 +512,17 @@ function defaultGetTextLines(data, targetId) {
     if (mean) {
         textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
     }
-    if (max) {
+    if (Number.isFinite(max)) {
         textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
     }
     if (stdDev) {
         textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     }
     if (perimeter) {
-        textLines.push(`Perimeter: ${roundNumber(perimeter)} ${pixelValueUnits}`);
+        textLines.push(`Perimeter: ${roundNumber(perimeter)} ${lengthUnits}`);
+    }
+    if (length) {
+        textLines.push(`${roundNumber(length)} ${lengthUnits}`);
     }
     return textLines;
 }

package/dist/esm/tools/annotation/ProbeTool.d.ts

@@ -1,13 +1,11 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { ProbeAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { ProbeAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class ProbeTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         newAnnotation?: boolean;
     } | null;
@@ -25,7 +23,7 @@ declare class ProbeTool extends AnnotationTool {
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: ProbeAnnotation): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: any) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: any) => void;
     _deactivateModify: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;

package/dist/esm/tools/annotation/ProbeTool.js

@@ -1,4 +1,4 @@
-import { vec2 } from 'gl-matrix';
+import { vec2, vec3 } from 'gl-matrix';
 import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
@@ -11,7 +11,7 @@ import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters'
 import { roundNumber } from '../../utilities';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getPixelValueUnits, } from '../../utilities/getPixelValueUnits';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
@@ -29,11 +29,11 @@ class ProbeTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
-            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
             const annotation = {
                 invalidated: true,
@@ -265,42 +265,27 @@ class ProbeTool extends AnnotationTool {
             if (!image) {
                 continue;
             }
-            const { dimensions, imageData, metadata } = image;
-            const scalarData = 'getScalarData' in image ? image.getScalarData() : image.scalarData;
+            const { dimensions, imageData, metadata, voxelManager } = image;
             const modality = metadata.Modality;
-            const index = transformWorldToIndex(imageData, worldPos);
-            index[0] = Math.round(index[0]);
-            index[1] = Math.round(index[1]);
-            index[2] = Math.round(index[2]);
-            const samplesPerPixel = scalarData.length / dimensions[2] / dimensions[1] / dimensions[0];
-            if (csUtils.indexWithinDimensions(index, dimensions)) {
+            let ijk = transformWorldToIndex(imageData, worldPos);
+            ijk = vec3.round(ijk, ijk);
+            if (csUtils.indexWithinDimensions(ijk, dimensions)) {
                 this.isHandleOutsideImage = false;
-                const yMultiple = dimensions[0] * samplesPerPixel;
-                const zMultiple = dimensions[0] * dimensions[1] * samplesPerPixel;
-                const baseIndex = index[2] * zMultiple +
-                    index[1] * yMultiple +
-                    index[0] * samplesPerPixel;
-                let value = samplesPerPixel > 2
-                    ? [
-                        scalarData[baseIndex],
-                        scalarData[baseIndex + 1],
-                        scalarData[baseIndex + 2],
-                    ]
-                    : scalarData[baseIndex];
+                let value = voxelManager.getAtIJKPoint(ijk);
                 if (targetId.startsWith('imageId:')) {
                     const imageId = targetId.split('imageId:')[1];
                     const imageURI = csUtils.imageIdToURI(imageId);
                     const viewports = csUtils.getViewportsWithImageURI(imageURI, renderingEngineId);
                     const viewport = viewports[0];
-                    index[2] = viewport.getCurrentImageIdIndex();
+                    ijk[2] = viewport.getCurrentImageIdIndex();
                 }
                 let pixelValueUnits;
                 if (modality === 'US') {
                     const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
-                        index,
+                        ijk,
                     ]);
                     const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
-                    value = hasEnhancedRegionValues ? calibratedResults.values : value;
+                    value = (hasEnhancedRegionValues ? calibratedResults.values : value);
                     pixelValueUnits = hasEnhancedRegionValues
                         ? calibratedResults.units
                         : 'raw';
@@ -309,7 +294,7 @@ class ProbeTool extends AnnotationTool {
                     pixelValueUnits = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
                 }
                 cachedStats[targetId] = {
-                    index,
+                    index: ijk,
                     value,
                     Modality: modality,
                     pixelValueUnits,
@@ -318,7 +303,7 @@ class ProbeTool extends AnnotationTool {
             else {
                 this.isHandleOutsideImage = true;
                 cachedStats[targetId] = {
-                    index,
+                    index: ijk,
                     Modality: modality,
                 };
             }

package/dist/esm/tools/annotation/RectangleROITool.d.ts

@@ -1,12 +1,12 @@
 import { AnnotationTool } from '../base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, ToolHandle, ToolProps, PublicToolProps, SVGDrawingHelper } from '../../types';
-import { RectangleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, ToolProps, PublicToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { RectangleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class RectangleROITool extends AnnotationTool {
     static toolName: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -22,7 +22,7 @@ declare class RectangleROITool extends AnnotationTool {
     handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: RectangleROIAnnotation, handle: ToolHandle) => void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;
     _activateModify: (element: any) => void;

package/dist/esm/tools/annotation/RectangleROITool.js

@@ -18,13 +18,13 @@ import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCur
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
-import { pointInShapeCallback } from '../../utilities/';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
 const { transformWorldToIndex } = csUtils;
 class RectangleROITool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            storePointData: false,
             shadow: true,
             preventHandleOutsideImage: false,
             getTextLines: defaultGetTextLines,
@@ -464,7 +464,7 @@ class RectangleROITool extends AnnotationTool {
                 if (!image) {
                     continue;
                 }
-                const { dimensions, imageData, metadata } = image;
+                const { dimensions, imageData, metadata, voxelManager } = image;
                 const pos1Index = transformWorldToIndex(imageData, worldPos1);
                 pos1Index[0] = Math.floor(pos1Index[0]);
                 pos1Index[1] = Math.floor(pos1Index[1]);
@@ -495,7 +495,11 @@ class RectangleROITool extends AnnotationTool {
                         isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
                     };
                     const pixelValueUnits = getPixelValueUnits(metadata.Modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
-                    const pointsInShape = pointInShapeCallback(imageData, () => true, this.configuration.statsCalculator.statsCallback, boundsIJK);
+                    const pointsInShape = voxelManager.forEach(this.configuration.statsCalculator.statsCallback, {
+                        boundsIJK,
+                        imageData,
+                        returnPoints: this.configuration.storePointData,
+                    });
                     const stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,

package/dist/esm/tools/annotation/SplineContourSegmentationTool.d.ts

@@ -1,4 +1,4 @@
-import { PublicToolProps } from '../../types';
+import type { PublicToolProps } from '../../types';
 import SplineROITool from './SplineROITool';
 declare class SplineContourSegmentationTool extends SplineROITool {
     static toolName: any;

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -17,9 +17,7 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     static toolName: any;
     static SplineTypes: typeof SplineTypesEnum;
     static Actions: typeof SplineToolActions;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
         annotation: SplineROIAnnotation;
         viewportIdsToRender: Array<string>;

package/dist/esm/tools/annotation/SplineROITool.js

@@ -576,7 +576,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
             const handleGroupUID = '0';
             drawHandlesSvg(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                 color,
-                lineWidth: Math.max(1, lineWidth),
+                lineWidth,
                 handleRadius: '3',
             });
         }
@@ -588,7 +588,7 @@ class SplineROITool extends ContourSegmentationBaseTool {
             const previewPolylinePoints = spline.getPreviewPolylinePoints(lastCanvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
             drawPolylineSvg(svgDrawingHelper, annotationUID, 'previewSplineChange', previewPolylinePoints, {
                 color: '#9EA0CA',
-                lineDash,
+                lineDash: lineDash,
                 lineWidth: 1,
             });
         }

package/dist/esm/tools/annotation/UltrasoundDirectionalTool.d.ts

@@ -1,15 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { UltrasoundDirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, InteractionTypes } from '../../types';
+import type { UltrasoundDirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, InteractionTypes } from '../../types';
 declare class UltrasoundDirectionalTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     startedDrawing: boolean;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -25,7 +23,7 @@ declare class UltrasoundDirectionalTool extends AnnotationTool {
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: UltrasoundDirectionalAnnotation, handle: ToolHandle): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;
     _activateDraw: (element: HTMLDivElement) => void;

package/dist/esm/tools/annotation/VideoRedactionTool.d.ts

@@ -1,17 +1,16 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, SVGDrawingHelper } from '../../types';
-import { VideoRedactionAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { Annotation, EventTypes, SVGDrawingHelper } from '../../types';
+import type { VideoRedactionAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class VideoRedactionTool extends AnnotationTool {
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportUIDsToRender: string[];
         handleIndex?: number;
         newAnnotation?: boolean;
         hasMoved?: boolean;
     } | null;
-    _configuration: any;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolConfiguration?: {});

package/dist/esm/tools/annotation/planarFreehandROITool/findOpenUShapedContourVectorToPeak.d.ts

@@ -1,4 +1,4 @@
 import type { Types } from '@cornerstonejs/core';
-import { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
+import type { PlanarFreehandROIAnnotation } from '../../../types/ToolSpecificAnnotationTypes';
 export default function findOpenUShapedContourVectorToPeak(canvasPoints: Types.Point2[], viewport: Types.IStackViewport | Types.IVolumeViewport): Types.Point3[];
 export declare function findOpenUShapedContourVectorToPeakOnRender(enabledElement: Types.IEnabledElement, annotation: PlanarFreehandROIAnnotation): Types.Point3[];

package/dist/esm/tools/annotation/splines/CardinalSpline.d.ts

@@ -1,5 +1,5 @@
 import { CubicSpline } from './CubicSpline';
-import { CardinalSplineProps } from '../../../types';
+import type { CardinalSplineProps } from '../../../types';
 declare class CardinalSpline extends CubicSpline {
     private _scale;
     private _fixedScale;

package/dist/esm/tools/annotation/splines/CubicSpline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Spline } from './Spline';
 import type { SplineCurveSegment } from '../../../types';
 declare abstract class CubicSpline extends Spline {

package/dist/esm/tools/annotation/splines/QuadraticSpline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { Spline } from './Spline';
 import type { SplineLineSegment, SplineCurveSegment } from '../../../types/';
 declare abstract class QuadraticSpline extends Spline {

package/dist/esm/tools/annotation/splines/Spline.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import type { ISpline, SplineProps, ClosestControlPoint, ClosestSplinePoint, ClosestPoint, ControlPointInfo, SplineCurveSegment } from '../../../types';
 declare abstract class Spline implements ISpline {
     private _controlPoints;