@cornerstonejs/tools 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/esm/tools/ScaleOverlayTool.js

@@ -44,27 +44,30 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
             if (annotations.length) {
                 annotation = annotations.filter((thisAnnotation) => thisAnnotation.data.viewportId == viewport.id)[0];
             }
-            if (!viewportsWithAnnotations.includes(viewport.id)) {
-                const newAnnotation = {
-                    metadata: {
-                        toolName: this.getToolName(),
-                        viewPlaneNormal: [...viewPlaneNormal],
-                        viewUp: [...viewUp],
-                        FrameOfReferenceUID,
-                        referencedImageId: null,
-                    },
-                    data: {
-                        handles: {
-                            points: viewportCanvasCornersInWorld,
+            enabledElements.forEach((element) => {
+                const { viewport } = element;
+                if (!viewportsWithAnnotations.includes(viewport.id)) {
+                    const newAnnotation = {
+                        metadata: {
+                            toolName: this.getToolName(),
+                            viewPlaneNormal: [...viewPlaneNormal],
+                            viewUp: [...viewUp],
+                            FrameOfReferenceUID,
+                            referencedImageId: null,
                         },
-                        viewportId: viewport.id,
-                    },
-                };
-                viewportsWithAnnotations.push(viewport.id);
-                addAnnotation(newAnnotation, viewport.element);
-                annotation = newAnnotation;
-            }
-            else if (this.editData.annotation &&
+                        data: {
+                            handles: {
+                                points: csUtils.getViewportImageCornersInWorld(viewport),
+                            },
+                            viewportId: viewport.id,
+                        },
+                    };
+                    viewportsWithAnnotations.push(viewport.id);
+                    addAnnotation(newAnnotation, viewport.element);
+                    annotation = newAnnotation;
+                }
+            });
+            if (this.editData.annotation &&
                 this.editData.annotation.data.viewportId == viewport.id) {
                 this.editData.annotation.data.handles.points =
                     viewportCanvasCornersInWorld;

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

@@ -10,10 +10,12 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
     static toolName: string;
     protected scissors: LivewireScissors;
     protected scissorsNext: LivewireScissors;
+    _throttledCalculateCachedStats: Function;
     editData: {
         annotation: LivewireContourAnnotation;
         viewportIdsToRender: Array<string>;
         handleIndex?: number;
+        movingTextBox?: boolean;
         newAnnotation?: boolean;
         hasMoved?: boolean;
         lastCanvasPoint?: Types.Point2;
@@ -57,6 +59,9 @@ declare class LivewireContourTool extends ContourSegmentationBaseTool {
         annotationStyle: AnnotationStyle;
         svgDrawingHelper: SVGDrawingHelper;
     }): boolean;
+    private _calculateCachedStats;
+    private _renderStats;
+    triggerAnnotationModified: (annotation: LivewireContourAnnotation, enabledElement: Types.IEnabledElement, changeType?: ChangeTypes) => void;
     protected updateAnnotation(livewirePath: LivewirePath): void;
 }
 export default LivewireContourTool;

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

@@ -1,7 +1,7 @@
 import { vec3 } from 'gl-matrix';
-import { getEnabledElement, utilities as csUtils, VolumeViewport, } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, VolumeViewport, utilities, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { removeAnnotation } from '../../stateManagement/annotation/annotationState';
-import { drawHandles as drawHandlesSvg } from '../../drawingSvg';
+import { drawHandles as drawHandlesSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { Events, KeyboardBindings, ChangeTypes } from '../../enums';
 import { resetElementCursor } from '../../cursors/elementCursor';
@@ -15,11 +15,15 @@ import { LivewireScissors } from '../../utilities/livewire/LivewireScissors';
 import { LivewirePath } from '../../utilities/livewire/LiveWirePath';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
+import { getTextBoxCoordsCanvas } from '../../utilities/drawing';
+import { getCalibratedLengthUnitsAndScale, throttle } from '../../utilities';
 const CLICK_CLOSE_CURVE_SQR_DIST = 10 ** 2;
 class LivewireContourTool extends ContourSegmentationBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
+            getTextLines: defaultGetTextLines,
+            calculateStats: true,
             preventHandleOutsideImage: false,
             contourHoleAdditionModifierKey: KeyboardBindings.Shift,
             snapHandleNearby: 2,
@@ -70,6 +74,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             this.editData = {
                 annotation,
                 viewportIdsToRender,
+                movingTextBox: false,
             };
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
@@ -82,13 +87,21 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             const { element } = eventDetail;
             const { data } = annotation;
             annotation.highlighted = true;
-            const { points } = data.handles;
-            const handleIndex = points.findIndex((p) => p === handle);
+            let movingTextBox = false;
+            let handleIndex;
+            if (handle.worldPosition) {
+                movingTextBox = true;
+            }
+            else {
+                const { points } = data.handles;
+                handleIndex = points.findIndex((p) => p === handle);
+            }
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName());
             this.editData = {
                 annotation,
                 viewportIdsToRender,
                 handleIndex,
+                movingTextBox,
             };
             this._activateModify(element);
             const enabledElement = getEnabledElement(element);
@@ -215,15 +228,27 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             this.isDrawing = true;
             const eventDetail = evt.detail;
             const { element } = eventDetail;
-            const { annotation, viewportIdsToRender, handleIndex } = this.editData;
-            if (handleIndex === undefined) {
-                console.warn('No drag implemented for livewire');
+            const { annotation, viewportIdsToRender, handleIndex, movingTextBox } = this.editData;
+            const { data } = annotation;
+            if (movingTextBox) {
+                const { deltaPoints } = eventDetail;
+                const worldPosDelta = deltaPoints.world;
+                const { textBox } = data.handles;
+                const { worldPosition } = textBox;
+                worldPosition[0] += worldPosDelta[0];
+                worldPosition[1] += worldPosDelta[1];
+                worldPosition[2] += worldPosDelta[2];
+                textBox.hasMoved = true;
+            }
+            else if (handleIndex === undefined) {
+                console.warn('Drag annotation not implemented');
             }
             else {
                 const { currentPoints } = eventDetail;
                 const worldPos = currentPoints.world;
                 this.editHandle(worldPos, element, annotation, handleIndex);
             }
+            this.editData.hasMoved = true;
             const enabledElement = getEnabledElement(element);
             const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
@@ -279,6 +304,104 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             element.removeEventListener(Events.MOUSE_DOUBLE_CLICK, this._mouseDownCallback);
             element.removeEventListener(Events.TOUCH_TAP, this._mouseDownCallback);
         };
+        this._calculateCachedStats = (annotation, element) => {
+            if (!this.configuration.calculateStats) {
+                return;
+            }
+            const data = annotation.data;
+            if (!data.contour.closed) {
+                return;
+            }
+            const enabledElement = getEnabledElement(element);
+            const { viewport, renderingEngine } = enabledElement;
+            const { cachedStats } = data;
+            const { polyline: points } = data.contour;
+            const targetIds = Object.keys(cachedStats);
+            for (let i = 0; i < targetIds.length; i++) {
+                const targetId = targetIds[i];
+                const image = this.getTargetIdImage(targetId, renderingEngine);
+                if (!image) {
+                    continue;
+                }
+                const { 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 { imageData } = image;
+                const { scale, areaUnit } = getCalibratedLengthUnitsAndScale(image, () => {
+                    const { maxX: canvasMaxX, maxY: canvasMaxY, minX: canvasMinX, minY: canvasMinY, } = math.polyline.getAABB(canvasCoordinates);
+                    const topLeftBBWorld = viewport.canvasToWorld([
+                        canvasMinX,
+                        canvasMinY,
+                    ]);
+                    const topLeftBBIndex = utilities.transformWorldToIndex(imageData, topLeftBBWorld);
+                    const bottomRightBBWorld = viewport.canvasToWorld([
+                        canvasMaxX,
+                        canvasMaxY,
+                    ]);
+                    const bottomRightBBIndex = utilities.transformWorldToIndex(imageData, bottomRightBBWorld);
+                    return [topLeftBBIndex, bottomRightBBIndex];
+                });
+                let area = math.polyline.getArea(canvasCoordinates) / scale / scale;
+                area *= deltaInX * deltaInY;
+                cachedStats[targetId] = {
+                    Modality: metadata.Modality,
+                    area,
+                    areaUnit: areaUnit,
+                };
+            }
+            this.triggerAnnotationModified(annotation, enabledElement, ChangeTypes.StatsUpdated);
+            return cachedStats;
+        };
+        this._renderStats = (annotation, viewport, svgDrawingHelper, textboxStyle) => {
+            const data = annotation.data;
+            const targetId = this.getTargetId(viewport);
+            if (!data.contour.closed || !textboxStyle.visibility) {
+                return;
+            }
+            const textLines = this.configuration.getTextLines(data, targetId);
+            if (!textLines || textLines.length === 0) {
+                return;
+            }
+            const canvasCoordinates = data.handles.points.map((p) => viewport.worldToCanvas(p));
+            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 = 'textBox';
+            const boundingBox = drawLinkedTextBoxSvg(svgDrawingHelper, annotation.annotationUID ?? '', textBoxUID, textLines, textBoxPosition, canvasCoordinates, {}, textboxStyle);
+            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]),
+            };
+        };
+        this.triggerAnnotationModified = (annotation, enabledElement, changeType = ChangeTypes.StatsUpdated) => {
+            const { viewportId, renderingEngineId } = enabledElement;
+            const eventType = Events.ANNOTATION_MODIFIED;
+            const eventDetail = {
+                annotation,
+                viewportId,
+                renderingEngineId,
+                changeType,
+            };
+            triggerEvent(eventTarget, eventType, eventDetail);
+        };
+        this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
     setupBaseEditData(worldPos, element, annotation, nextPos, contourHoleProcessingEnabled) {
         const enabledElement = getEnabledElement(element);
@@ -432,6 +555,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         editData.currentPath = currentPath;
         annotation.invalidated = true;
         editData.hasMoved = true;
+        editData.closed = true;
     }
     renderAnnotation(enabledElement, svgDrawingHelper) {
         this.updateAnnotation(this.editData?.currentPath);
@@ -459,8 +583,9 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         this._endCallback(evt, true);
     }
     renderAnnotationInstance(renderContext) {
-        const { annotation, enabledElement, svgDrawingHelper, annotationStyle } = renderContext;
+        const { annotation, enabledElement, svgDrawingHelper, annotationStyle, targetId, } = renderContext;
         const { viewport } = enabledElement;
+        const { element } = viewport;
         const { worldToCanvas } = viewport;
         const { annotationUID, data, highlighted } = annotation;
         const { handles } = data;
@@ -478,6 +603,19 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             });
         }
         super.renderAnnotationInstance(renderContext);
+        if (!data.cachedStats[targetId] ||
+            data.cachedStats[targetId].areaUnit == null) {
+            data.cachedStats[targetId] = {
+                Modality: null,
+                area: null,
+                areaUnit: null,
+            };
+            this._calculateCachedStats(annotation, element);
+        }
+        else if (annotation.invalidated) {
+            this._throttledCalculateCachedStats(annotation, element);
+        }
+        this._renderStats(annotation, viewport, svgDrawingHelper, annotationStyle.textbox);
         return true;
     }
     updateAnnotation(livewirePath) {
@@ -502,3 +640,13 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
 }
 LivewireContourTool.toolName = 'LivewireContour';
 export default LivewireContourTool;
+function defaultGetTextLines(data, targetId) {
+    const cachedVolumeStats = data.cachedStats[targetId];
+    const { area, areaUnit } = cachedVolumeStats;
+    const textLines = [];
+    if (area) {
+        const areaLine = `Area: ${csUtils.roundNumber(area)} ${areaUnit}`;
+        textLines.push(areaLine);
+    }
+    return textLines;
+}

package/dist/esm/tools/base/BaseTool.d.ts

@@ -2,19 +2,7 @@ import type { Types } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 import type StrategyCallbacks from '../../enums/StrategyCallbacks';
 import type { InteractionTypes, ToolProps, PublicToolProps } from '../../types';
-export interface IBaseTool {
-    toolGroupId: string;
-    supportedInteractionTypes: InteractionTypes[];
-    mode: ToolModes;
-    configuration: {
-        preventHandleOutsideImage?: boolean;
-        strategies?: Record<string, unknown>;
-        defaultStrategy?: string;
-        activeStrategy?: string;
-        strategyOptions?: Record<string, unknown>;
-    };
-}
-declare abstract class BaseTool implements IBaseTool {
+declare abstract class BaseTool {
     static toolName: any;
     supportedInteractionTypes: InteractionTypes[];
     configuration: Record<string, any>;

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -128,7 +128,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const activeSegRep = getActiveSegmentationRepresentation(viewportId);
         const isActive = activeSegRep.segmentationRepresentationUID ===
             segmentationRepresentationUID;
-        const mergedConfig = Object.assign({}, globalConfig?.representations?.CONTOUR ?? {}, segmentationRepresentationConfig?.CONTOUR ?? {}, segmentConfig?.CONTOUR ?? {});
+        const mergedConfig = Object.assign({}, globalConfig?.representations?.Contour ?? {}, segmentationRepresentationConfig ?? {}, segmentConfig ?? {});
         let lineWidth = 1;
         let lineDash = undefined;
         let lineOpacity = 1;

package/dist/esm/tools/displayTools/Contour/contourHandler/handleContourSegmentation.js

@@ -15,8 +15,8 @@ function handleContourSegmentation(viewport, geometryIds, annotationUIDsMap, con
 }
 function updateContourSets(viewport, geometryIds, contourRepresentation) {
     const { segmentationRepresentationUID, config } = contourRepresentation;
-    const baseConfig = config?.allSegments?.CONTOUR;
-    const globalContourConfig = getGlobalConfig().representations.CONTOUR;
+    const baseConfig = config?.allSegments;
+    const globalContourConfig = getGlobalConfig().representations.Contour;
     const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
     const cachedConfig = getConfigCache(segmentationRepresentationUID);
     const newOutlineWithActive = newContourConfig.outlineWidthActive;
@@ -112,8 +112,8 @@ function addContourSetsToElement(viewport, geometryIds, contourRepresentation) {
             segmentSpecificMap.set(segmentIndex, segmentSpecificConfig);
         }
     });
-    const baseConfig = contourRepresentation.config?.allSegments.CONTOUR;
-    const globalContourConfig = getGlobalConfig().representations.CONTOUR;
+    const baseConfig = contourRepresentation.config?.allSegments;
+    const globalContourConfig = getGlobalConfig().representations.Contour;
     const newContourConfig = utilities.deepMerge(globalContourConfig, baseConfig);
     const outlineWidthActive = newContourConfig.outlineWidthActive;
     const segmentsHidden = getHiddenSegmentIndices(viewport.id, segmentationRepresentationUID);

package/dist/esm/tools/displayTools/Contour/contourHandler/utils.js

@@ -7,7 +7,7 @@ export function validateGeometry(geometry) {
         throw new Error(`No contours found for geometryId ${geometry.id}`);
     }
     const geometryId = geometry.id;
-    if (geometry.type !== Enums.GeometryType.CONTOUR) {
+    if (geometry.type !== Enums.GeometryType.Contour) {
         throw new Error(`Geometry type ${geometry.type} not supported for rendering.`);
     }
     if (!geometry.data) {

package/dist/esm/tools/displayTools/Contour/removeContourFromElement.js

@@ -4,7 +4,7 @@ function removeContourFromElement(element, segmentationRepresentationUID, remove
     const segmentationRepresentation = getSegmentationRepresentation(segmentationRepresentationUID);
     const { segmentationId } = segmentationRepresentation;
     const segmentation = getSegmentation(segmentationId);
-    const { annotationUIDsMap } = segmentation.representationData.CONTOUR;
+    const { annotationUIDsMap } = segmentation.representationData.Contour;
     annotationUIDsMap.forEach((annotationSet) => {
         annotationSet.forEach((annotationUID) => {
             removeAnnotation(annotationUID);

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

@@ -171,30 +171,35 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
                 const canvasCorners = getCanvasCircleCorners(canvasCoordinates);
                 const focalPoint = viewport.getCamera().focalPoint;
                 const viewplaneNormal = viewport.getCamera().viewPlaneNormal;
-                let startCoord = startCoordinate;
-                let endCoord = endCoordinate;
+                let tempStartCoordinate = startCoordinate;
+                let tempEndCoordinate = endCoordinate;
                 if (Array.isArray(startCoordinate)) {
-                    startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    tempStartCoordinate = this._getCoordinateForViewplaneNormal(tempStartCoordinate, viewplaneNormal);
+                    data.startCoordinate = tempStartCoordinate;
                 }
                 if (Array.isArray(endCoordinate)) {
-                    endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    tempEndCoordinate = this._getCoordinateForViewplaneNormal(tempEndCoordinate, viewplaneNormal);
+                    data.endCoordinate = tempEndCoordinate;
                 }
-                const roundedStartCoord = coreUtils.roundToPrecision(startCoord);
-                const roundedEndCoord = coreUtils.roundToPrecision(endCoord);
-                const coord = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
-                const roundedCoord = coreUtils.roundToPrecision(coord);
-                if (roundedCoord < Math.min(roundedStartCoord, roundedEndCoord) ||
-                    roundedCoord > Math.max(roundedStartCoord, roundedEndCoord)) {
+                const roundedStartCoordinate = coreUtils.roundToPrecision(data.startCoordinate);
+                const roundedEndCoordinate = coreUtils.roundToPrecision(data.endCoordinate);
+                const cameraCoordinate = this._getCoordinateForViewplaneNormal(focalPoint, viewplaneNormal);
+                const roundedCameraCoordinate = coreUtils.roundToPrecision(cameraCoordinate);
+                if (roundedCameraCoordinate <
+                    Math.min(roundedStartCoordinate, roundedEndCoordinate) ||
+                    roundedCameraCoordinate >
+                        Math.max(roundedStartCoordinate, roundedEndCoordinate)) {
                     continue;
                 }
-                if (annotation.invalidated) {
-                    this._throttledCalculateCachedStats(annotation, enabledElement);
-                }
-                const middleCoord = coreUtils.roundToPrecision((startCoord + endCoord) / 2);
+                const middleCoordinate = coreUtils.roundToPrecision((data.startCoordinate + data.endCoordinate) / 2);
                 let isMiddleSlice = false;
-                if (roundedCoord === middleCoord) {
+                if (roundedCameraCoordinate === middleCoordinate) {
                     isMiddleSlice = true;
                 }
+                data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = middleCoordinate;
+                if (annotation.invalidated) {
+                    this._throttledCalculateCachedStats(annotation, enabledElement);
+                }
                 if (!viewport.getRenderingEngine()) {
                     console.warn('Rendering Engine has been destroyed');
                     return renderStatus;
@@ -420,6 +425,9 @@ class CircleROIStartEndThresholdTool extends CircleROITool {
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, imageVolume, targetId, enabledElement);
+        }
         annotation.invalidated = false;
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;

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

@@ -172,9 +172,15 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
                 let endCoord = endCoordinate;
                 if (Array.isArray(startCoordinate)) {
                     startCoord = this._getCoordinateForViewplaneNormal(startCoord, viewplaneNormal);
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
+                    data.startCoordinate = startCoord;
+                    data.handles.points[0][this._getIndexOfCoordinatesForViewplaneNormal(viewplaneNormal)] = startCoord;
                 }
                 if (Array.isArray(endCoordinate)) {
                     endCoord = this._getCoordinateForViewplaneNormal(endCoord, viewplaneNormal);
+                    data.endCoordinate = endCoord;
+                    data.endCoordinate = endCoord;
                 }
                 const roundedStartCoord = csUtils.roundToPrecision(startCoord);
                 const roundedEndCoord = csUtils.roundToPrecision(endCoord);
@@ -378,6 +384,12 @@ class RectangleROIStartEndThresholdTool extends RectangleROITool {
         const targetId = this.getTargetId(viewport);
         const imageVolume = cache.getVolume(targetId.split(/volumeId:|\?/)[1]);
         this._computeProjectionPoints(annotation, imageVolume);
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
+        if (this.configuration.calculatePointsInsideVolume) {
+            this._computePointsInsideVolume(annotation, targetId, imageVolume, enabledElement);
+        }
         annotation.invalidated = false;
         triggerAnnotationModified(annotation, viewport.element);
         return cachedStats;

package/dist/esm/types/EventTypes.d.ts

@@ -5,9 +5,8 @@ import type ITouchPoints from './ITouchPoints';
 import type IDistance from './IDistance';
 import type { SetToolBindingsType } from './ISetToolModeOptions';
 import type { Swipe } from '../enums/Touch';
-import type { ToolModes } from '../enums';
+import type { ToolModes, ChangeTypes } from '../enums';
 import type { InterpolationROIAnnotation } from './ToolSpecificAnnotationTypes';
-import type { ChangeTypes } from '../enums';
 type NormalizedInteractionEventDetail = {
     eventName: string;
     renderingEngineId: string;

package/dist/esm/types/IBaseTool.d.ts

@@ -0,0 +1,2 @@
+import type BaseTool from '../tools/base/BaseTool';
+export type IBaseTool = BaseTool;

package/dist/esm/types/IBaseTool.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/IToolGroup.d.ts

@@ -1,63 +1,3 @@
-import type { Types } from '@cornerstonejs/core';
-import type { IToolBinding, SetToolBindingsType, ToolOptionsType } from './ISetToolModeOptions';
-import type { MouseBindings } from '../enums';
-import type { ToolConfiguration } from '../types';
-export default interface IToolGroup {
-    _toolInstances: Record<string, unknown>;
-    id: string;
-    viewportsInfo: Array<Types.IViewportId>;
-    toolOptions: Record<string, unknown>;
-    getViewportIds: () => string[];
-    getViewportsInfo: () => Array<Types.IViewportId>;
-    getToolInstance: {
-        (toolName: string): unknown;
-    };
-    hasTool(toolName: string): boolean;
-    addTool: {
-        (toolName: string, toolConfiguration?: ToolConfiguration): void;
-    };
-    addToolInstance: {
-        (toolName: string, parentClassName: string, configuration?: unknown): void;
-    };
-    addViewport: {
-        (viewportId: string, renderingEngineId?: string): void;
-    };
-    removeViewports: {
-        (renderingEngineId: string, viewportId?: string): void;
-    };
-    setToolActive: {
-        (toolName: string, toolBindingsOption?: SetToolBindingsType): void;
-    };
-    setToolPassive: {
-        (toolName: string, options?: {
-            removeAllBindings?: boolean | IToolBinding[];
-        }): void;
-    };
-    setToolEnabled: {
-        (toolName: string): void;
-    };
-    setToolDisabled: {
-        (toolName: string): void;
-    };
-    getToolOptions: {
-        (toolName: string): ToolOptionsType;
-    };
-    getActivePrimaryMouseButtonTool: {
-        (): undefined | string;
-    };
-    setViewportsCursorByToolName: {
-        (toolName: string, strategyName?: string): void;
-    };
-    setToolConfiguration: {
-        (toolName: string, configuration: ToolConfiguration, overwrite?: boolean): void;
-    };
-    getToolConfiguration: {
-        (toolName: string, configurationPath?: string): unknown;
-    };
-    getDefaultMousePrimary: {
-        (): MouseBindings;
-    };
-    clone: {
-        (newToolGroupId: string, fnToolFilter: (toolName: string) => boolean): IToolGroup;
-    };
-}
+import type ToolGroup from '../store/ToolGroupManager/ToolGroup';
+type IToolGroup = ToolGroup;
+export type { IToolGroup as default };