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

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

@@ -1,14 +1,17 @@
 import { vec2 } from 'gl-matrix';
-import { getEnabledElement, VolumeViewport, triggerEvent, eventTarget, utilities as csUtils, utilities, } from '@cornerstonejs/core';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
+import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUnits';
 import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store';
 import { Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import { roundNumber } from '../../utilities';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getModalityUnit, } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits, } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
@@ -58,16 +61,14 @@ class ProbeTool extends AnnotationTool {
             this._activateModify(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this._endCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
             const { annotation, viewportIdsToRender, newAnnotation } = this.editData;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
-            const { viewportId } = enabledElement;
+            const { viewportId, renderingEngine } = getEnabledElement(element);
             this.eventDispatchDetail = {
                 viewportId,
                 renderingEngineId: renderingEngine.id,
@@ -80,13 +81,9 @@ class ProbeTool extends AnnotationTool {
                 this.configuration.preventHandleOutsideImage) {
                 removeAnnotation(annotation.annotationUID);
             }
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
-                const eventType = Events.ANNOTATION_COMPLETED;
-                const eventDetail = {
-                    annotation,
-                };
-                triggerEvent(eventTarget, eventType, eventDetail);
+                triggerAnnotationCompleted(annotation);
             }
         };
         this._dragCallback = (evt) => {
@@ -100,7 +97,7 @@ class ProbeTool extends AnnotationTool {
             annotation.invalidated = true;
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.cancel = (element) => {
             if (this.isDrawing) {
@@ -111,15 +108,9 @@ class ProbeTool extends AnnotationTool {
                 const { data } = annotation;
                 annotation.highlighted = false;
                 data.handles.activeHandleIndex = null;
-                const enabledElement = getEnabledElement(element);
-                const { renderingEngine } = enabledElement;
-                triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+                triggerAnnotationRenderForViewportIds(viewportIdsToRender);
                 if (newAnnotation) {
-                    const eventType = Events.ANNOTATION_COMPLETED;
-                    const eventDetail = {
-                        annotation,
-                    };
-                    triggerEvent(eventTarget, eventType, eventDetail);
+                    triggerAnnotationCompleted(annotation);
                 }
                 this.editData = null;
                 return annotation.annotationUID;
@@ -169,21 +160,21 @@ class ProbeTool extends AnnotationTool {
                 const point = data.handles.points[0];
                 const canvasCoordinates = viewport.worldToCanvas(point);
                 styleSpecifier.annotationUID = annotationUID;
-                const color = this.getStyle('color', styleSpecifier, annotation);
-                const modalityUnitOptions = {
-                    isPreScaled: isViewportPreScaled(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
-                if (!data.cachedStats[targetId]) {
+                const { color } = this.getAnnotationStyle({ annotation, styleSpecifier });
+                if (!data.cachedStats) {
+                    data.cachedStats = {};
+                }
+                if (!data.cachedStats[targetId] ||
+                    data.cachedStats[targetId].value == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         index: null,
                         value: null,
                     };
-                    this._calculateCachedStats(annotation, renderingEngine, enabledElement, modalityUnitOptions);
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
                 }
                 else if (annotation.invalidated) {
-                    this._calculateCachedStats(annotation, renderingEngine, enabledElement, modalityUnitOptions);
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
                     if (viewport instanceof VolumeViewport) {
                         const { referencedImageId } = annotation.metadata;
                         for (const targetId in data.cachedStats) {
@@ -254,17 +245,22 @@ class ProbeTool extends AnnotationTool {
         hideElementCursor(element);
         const enabledElement = getEnabledElement(element);
         const { renderingEngine } = enabledElement;
-        triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         evt.preventDefault();
     }
-    _calculateCachedStats(annotation, renderingEngine, enabledElement, modalityUnitOptions) {
+    _calculateCachedStats(annotation, renderingEngine, enabledElement) {
         const data = annotation.data;
-        const { viewportId, renderingEngineId } = enabledElement;
+        const { renderingEngineId, viewport } = enabledElement;
+        const { element } = viewport;
         const worldPos = data.handles.points[0];
         const { cachedStats } = data;
         const targetIds = Object.keys(cachedStats);
         for (let i = 0; i < targetIds.length; i++) {
             const targetId = targetIds[i];
+            const pixelUnitsOptions = {
+                isPreScaled: isViewportPreScaled(viewport, targetId),
+                isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+            };
             const image = this.getTargetIdImage(targetId, renderingEngine);
             if (!image) {
                 continue;
@@ -276,24 +272,47 @@ class ProbeTool extends AnnotationTool {
             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)) {
                 this.isHandleOutsideImage = false;
-                const yMultiple = dimensions[0];
-                const zMultiple = dimensions[0] * dimensions[1];
-                const value = scalarData[index[2] * zMultiple + index[1] * yMultiple + index[0]];
+                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];
                 if (targetId.startsWith('imageId:')) {
                     const imageId = targetId.split('imageId:')[1];
                     const imageURI = csUtils.imageIdToURI(imageId);
-                    const viewports = utilities.getViewportsWithImageURI(imageURI, renderingEngineId);
+                    const viewports = csUtils.getViewportsWithImageURI(imageURI, renderingEngineId);
                     const viewport = viewports[0];
                     index[2] = viewport.getCurrentImageIdIndex();
                 }
-                const modalityUnit = getModalityUnit(modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                let pixelValueUnits;
+                if (modality === 'US') {
+                    const calibratedResults = getCalibratedProbeUnitsAndValue(image, [
+                        index,
+                    ]);
+                    const hasEnhancedRegionValues = calibratedResults.values.every((value) => value !== null);
+                    value = hasEnhancedRegionValues ? calibratedResults.values : value;
+                    pixelValueUnits = hasEnhancedRegionValues
+                        ? calibratedResults.units
+                        : 'raw';
+                }
+                else {
+                    pixelValueUnits = getPixelValueUnits(modality, annotation.metadata.referencedImageId, pixelUnitsOptions);
+                }
                 cachedStats[targetId] = {
                     index,
                     value,
                     Modality: modality,
-                    modalityUnit,
+                    pixelValueUnits,
                 };
             }
             else {
@@ -304,28 +323,28 @@ class ProbeTool extends AnnotationTool {
                 };
             }
             annotation.invalidated = false;
-            const eventType = Events.ANNOTATION_MODIFIED;
-            const eventDetail = {
-                annotation,
-                viewportId,
-                renderingEngineId,
-            };
-            triggerEvent(eventTarget, eventType, eventDetail);
+            triggerAnnotationModified(annotation, element);
         }
         return cachedStats;
     }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { index, value, modalityUnit } = cachedVolumeStats;
+    const { index, value, pixelValueUnits } = cachedVolumeStats;
     if (value === undefined) {
         return;
     }
     const textLines = [];
     textLines.push(`(${index[0]}, ${index[1]}, ${index[2]})`);
-    textLines.push(`${value.toFixed(2)} ${modalityUnit}`);
+    if (value instanceof Array && pixelValueUnits instanceof Array) {
+        for (let i = 0; i < value.length; i++) {
+            textLines.push(`${roundNumber(value[i])} ${pixelValueUnits[i]}`);
+        }
+    }
+    else {
+        textLines.push(`${roundNumber(value)} ${pixelValueUnits}`);
+    }
     return textLines;
 }
 ProbeTool.toolName = 'Probe';
 export default ProbeTool;
-//# sourceMappingURL=ProbeTool.js.map

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

@@ -34,7 +34,7 @@ declare class RectangleROITool extends AnnotationTool {
         width: number;
         height: number;
     };
-    _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, renderingEngine: any, enabledElement: any, modalityUnitOptions: any) => any;
+    _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, renderingEngine: any, enabledElement: any) => any;
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
 }
 export default RectangleROITool;

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

@@ -1,12 +1,13 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, triggerEvent, eventTarget, utilities as csUtils, } from '@cornerstonejs/core';
-import { getCalibratedAreaUnits, getCalibratedScale, } from '../../utilities/getCalibratedUnits';
-import roundNumber from '../../utilities/roundNumber';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
+import { roundNumber } from '../../utilities';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
 import { isAnnotationLocked } from '../../stateManagement/annotation/annotationLocking';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
-import { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawRect as drawRectSvg, } from '../../drawingSvg';
+import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
+import { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, drawRectByCoordinates as drawRectSvg, } from '../../drawingSvg';
 import { state } from '../../store';
 import { Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
@@ -15,7 +16,7 @@ import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
 import getWorldWidthAndHeightFromCorners from '../../utilities/planar/getWorldWidthAndHeightFromCorners';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getModalityUnit } from '../../utilities/getModalityUnit';
+import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 import { pointInShapeCallback } from '../../utilities/';
 import { BasicStatsCalculator } from '../../utilities/math/basic';
@@ -51,6 +52,7 @@ class RectangleROITool extends AnnotationTool {
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -89,7 +91,7 @@ class RectangleROITool extends AnnotationTool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return annotation;
         };
         this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
@@ -125,7 +127,7 @@ class RectangleROITool extends AnnotationTool {
             hideElementCursor(element);
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
         this.handleSelectedCallback = (evt, annotation, handle) => {
@@ -152,7 +154,7 @@ class RectangleROITool extends AnnotationTool {
             hideElementCursor(element);
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
         };
         this._endCallback = (evt) => {
@@ -167,21 +169,16 @@ class RectangleROITool extends AnnotationTool {
             this._deactivateModify(element);
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
+            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             if (this.isHandleOutsideImage &&
                 this.configuration.preventHandleOutsideImage) {
                 removeAnnotation(annotation.annotationUID);
             }
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             if (newAnnotation) {
-                const eventType = Events.ANNOTATION_COMPLETED;
-                const eventDetail = {
-                    annotation,
-                };
-                triggerEvent(eventTarget, eventType, eventDetail);
+                triggerAnnotationCompleted(annotation);
             }
         };
         this._dragCallback = (evt) => {
@@ -261,7 +258,7 @@ class RectangleROITool extends AnnotationTool {
             this.editData.hasMoved = true;
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.cancel = (element) => {
             if (this.isDrawing) {
@@ -273,15 +270,9 @@ class RectangleROITool extends AnnotationTool {
                 const { data } = annotation;
                 annotation.highlighted = false;
                 data.handles.activeHandleIndex = null;
-                const enabledElement = getEnabledElement(element);
-                const { renderingEngine } = enabledElement;
-                triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+                triggerAnnotationRenderForViewportIds(viewportIdsToRender);
                 if (newAnnotation) {
-                    const eventType = Events.ANNOTATION_COMPLETED;
-                    const eventDetail = {
-                        annotation,
-                    };
-                    triggerEvent(eventTarget, eventType, eventDetail);
+                    triggerAnnotationCompleted(annotation);
                 }
                 this.editData = null;
                 return annotation.annotationUID;
@@ -350,28 +341,25 @@ class RectangleROITool extends AnnotationTool {
                 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);
+                const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
                 const { viewPlaneNormal, viewUp } = viewport.getCamera();
-                const modalityUnitOptions = {
-                    isPreScaled: isViewportPreScaled(viewport, targetId),
-                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                };
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].areaUnit === undefined) {
+                    data.cachedStats[targetId].areaUnits == null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         area: null,
                         max: null,
                         mean: null,
                         stdDev: null,
-                        areaUnit: null,
+                        areaUnits: null,
                     };
-                    this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement, modalityUnitOptions);
+                    this._calculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
                 }
                 else if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement, modalityUnitOptions);
+                    this._throttledCalculateCachedStats(annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement);
                     if (viewport instanceof VolumeViewport) {
                         const { referencedImageId } = annotation.metadata;
                         for (const targetId in data.cachedStats) {
@@ -411,7 +399,7 @@ class RectangleROITool extends AnnotationTool {
                 }
                 const dataId = `${annotationUID}-rect`;
                 const rectangleUID = '0';
-                drawRectSvg(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                drawRectSvg(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates, {
                     color,
                     lineDash,
                     lineWidth,
@@ -462,9 +450,10 @@ class RectangleROITool extends AnnotationTool {
                 height: Math.abs(point0[1] - point1[1]),
             };
         };
-        this._calculateCachedStats = (annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement, modalityUnitOptions) => {
+        this._calculateCachedStats = (annotation, viewPlaneNormal, viewUp, renderingEngine, enabledElement) => {
             const { data } = annotation;
-            const { viewportId, renderingEngineId } = enabledElement;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
             const worldPos1 = data.handles.points[0];
             const worldPos2 = data.handles.points[3];
             const { cachedStats } = data;
@@ -476,44 +465,48 @@ class RectangleROITool extends AnnotationTool {
                     continue;
                 }
                 const { dimensions, imageData, metadata } = image;
-                const scalarData = 'getScalarData' in image ? image.getScalarData() : image.scalarData;
-                const worldPos1Index = transformWorldToIndex(imageData, worldPos1);
-                worldPos1Index[0] = Math.floor(worldPos1Index[0]);
-                worldPos1Index[1] = Math.floor(worldPos1Index[1]);
-                worldPos1Index[2] = Math.floor(worldPos1Index[2]);
-                const worldPos2Index = transformWorldToIndex(imageData, worldPos2);
-                worldPos2Index[0] = Math.floor(worldPos2Index[0]);
-                worldPos2Index[1] = Math.floor(worldPos2Index[1]);
-                worldPos2Index[2] = Math.floor(worldPos2Index[2]);
-                if (this._isInsideVolume(worldPos1Index, worldPos2Index, dimensions)) {
+                const pos1Index = transformWorldToIndex(imageData, worldPos1);
+                pos1Index[0] = Math.floor(pos1Index[0]);
+                pos1Index[1] = Math.floor(pos1Index[1]);
+                pos1Index[2] = Math.floor(pos1Index[2]);
+                const pos2Index = transformWorldToIndex(imageData, worldPos2);
+                pos2Index[0] = Math.floor(pos2Index[0]);
+                pos2Index[1] = Math.floor(pos2Index[1]);
+                pos2Index[2] = Math.floor(pos2Index[2]);
+                if (this._isInsideVolume(pos1Index, pos2Index, dimensions)) {
                     this.isHandleOutsideImage = false;
-                    const iMin = Math.min(worldPos1Index[0], worldPos2Index[0]);
-                    const iMax = Math.max(worldPos1Index[0], worldPos2Index[0]);
-                    const jMin = Math.min(worldPos1Index[1], worldPos2Index[1]);
-                    const jMax = Math.max(worldPos1Index[1], worldPos2Index[1]);
-                    const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
-                    const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
+                    const iMin = Math.min(pos1Index[0], pos2Index[0]);
+                    const iMax = Math.max(pos1Index[0], pos2Index[0]);
+                    const jMin = Math.min(pos1Index[1], pos2Index[1]);
+                    const jMax = Math.max(pos1Index[1], pos2Index[1]);
+                    const kMin = Math.min(pos1Index[2], pos2Index[2]);
+                    const kMax = Math.max(pos1Index[2], pos2Index[2]);
                     const boundsIJK = [
                         [iMin, iMax],
                         [jMin, jMax],
                         [kMin, kMax],
                     ];
                     const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                    const scale = getCalibratedScale(image);
+                    const handles = [pos1Index, pos2Index];
+                    const { scale, areaUnits } = getCalibratedLengthUnitsAndScale(image, handles);
                     const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
-                    const modalityUnit = getModalityUnit(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                    const pixelUnitsOptions = {
+                        isPreScaled: isViewportPreScaled(viewport, targetId),
+                        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 stats = this.configuration.statsCalculator.getStatistics();
                     cachedStats[targetId] = {
                         Modality: metadata.Modality,
                         area,
-                        mean: stats[1]?.value,
-                        stdDev: stats[2]?.value,
-                        max: stats[0]?.value,
-                        statsArray: stats,
+                        mean: stats.mean?.value,
+                        stdDev: stats.stdDev?.value,
+                        max: stats.max?.value,
+                        statsArray: stats.array,
                         pointsInShape: pointsInShape,
-                        areaUnit: getCalibratedAreaUnits(null, image),
-                        modalityUnit,
+                        areaUnits,
+                        pixelValueUnits,
                     };
                 }
                 else {
@@ -524,13 +517,7 @@ class RectangleROITool extends AnnotationTool {
                 }
             }
             annotation.invalidated = false;
-            const eventType = Events.ANNOTATION_MODIFIED;
-            const eventDetail = {
-                annotation,
-                viewportId,
-                renderingEngineId,
-            };
-            triggerEvent(eventTarget, eventType, eventDetail);
+            triggerAnnotationModified(annotation, element);
             return cachedStats;
         };
         this._isInsideVolume = (index1, index2, dimensions) => {
@@ -542,17 +529,16 @@ class RectangleROITool extends AnnotationTool {
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+    const { area, mean, max, stdDev, areaUnits, pixelValueUnits } = cachedVolumeStats;
     if (mean === undefined) {
         return;
     }
     const textLines = [];
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
-    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+    textLines.push(`Area: ${roundNumber(area)} ${areaUnits}`);
+    textLines.push(`Mean: ${roundNumber(mean)} ${pixelValueUnits}`);
+    textLines.push(`Max: ${roundNumber(max)} ${pixelValueUnits}`);
+    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${pixelValueUnits}`);
     return textLines;
 }
 RectangleROITool.toolName = 'RectangleROI';
 export default RectangleROITool;
-//# sourceMappingURL=RectangleROITool.js.map

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

@@ -0,0 +1,8 @@
+import { PublicToolProps } from '../../types';
+import SplineROITool from './SplineROITool';
+declare class SplineContourSegmentationTool extends SplineROITool {
+    static toolName: any;
+    constructor(toolProps: PublicToolProps);
+    protected isContourSegmentationTool(): boolean;
+}
+export default SplineContourSegmentationTool;

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

@@ -0,0 +1,17 @@
+import { utilities } from '@cornerstonejs/core';
+import SplineROITool from './SplineROITool';
+class SplineContourSegmentationTool extends SplineROITool {
+    constructor(toolProps) {
+        const initialProps = utilities.deepMerge({
+            configuration: {
+                calculateStats: false,
+            },
+        }, toolProps);
+        super(initialProps);
+    }
+    isContourSegmentationTool() {
+        return true;
+    }
+}
+SplineContourSegmentationTool.toolName = 'SplineContourSegmentationTool';
+export default SplineContourSegmentationTool;

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

@@ -0,0 +1,71 @@
+import type { Types } from '@cornerstonejs/core';
+import { ChangeTypes } from '../../enums';
+import type { Annotation, EventTypes, ToolHandle, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
+import type { SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
+declare enum SplineTypesEnum {
+    Cardinal = "CARDINAL",
+    Linear = "LINEAR",
+    CatmullRom = "CATMULLROM",
+    BSpline = "BSPLINE"
+}
+declare enum SplineToolActions {
+    AddControlPoint = "addControlPoint",
+    DeleteControlPoint = "deleteControlPoint"
+}
+declare class SplineROITool extends ContourSegmentationBaseTool {
+    static toolName: any;
+    static SplineTypes: typeof SplineTypesEnum;
+    static Actions: typeof SplineToolActions;
+    touchDragCallback: any;
+    mouseDragCallback: any;
+    _throttledCalculateCachedStats: any;
+    editData: {
+        annotation: SplineROIAnnotation;
+        viewportIdsToRender: Array<string>;
+        handleIndex?: number;
+        movingTextBox?: boolean;
+        newAnnotation?: boolean;
+        hasMoved?: boolean;
+        lastCanvasPoint?: Types.Point2;
+        contourHoleProcessingEnabled?: boolean;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    fireChangeOnUpdate: {
+        annotationUID: string;
+        changeType: ChangeTypes;
+        contourHoleProcessingEnabled: boolean;
+    };
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    addNewAnnotation(evt: EventTypes.InteractionEventType): SplineROIAnnotation;
+    isPointNearTool: (element: HTMLDivElement, annotation: SplineROIAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation, handle: ToolHandle) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    private _keyDownCallback;
+    private _mouseMoveCallback;
+    private _mouseDownCallback;
+    private _dragCallback;
+    cancel(element: HTMLDivElement): string;
+    triggerAnnotationCompleted: (annotation: SplineROIAnnotation, contourHoleProcessingEnabled: boolean) => void;
+    triggerAnnotationModified: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType?: ChangeTypes) => void;
+    triggerChangeEvent: (annotation: SplineROIAnnotation, enabledElement: Types.IEnabledElement, changeType: ChangeTypes, contourHoleProcessingEnabled: any) => void;
+    private _activateModify;
+    private _deactivateModify;
+    private _activateDraw;
+    private _deactivateDraw;
+    protected isContourSegmentationTool(): boolean;
+    protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
+    protected createInterpolatedSplineControl(annotation: any): void;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    private _renderStats;
+    addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    private _deleteControlPointByIndex;
+    deleteControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
+    _isSplineROIAnnotation(annotation: Annotation): annotation is SplineROIAnnotation;
+    private _getSplineConfig;
+    private _updateSplineInstance;
+    private _calculateCachedStats;
+}
+export default SplineROITool;