@cornerstonejs/tools 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/esm/stateManagement/segmentation/polySeg/Surface/createAndCacheSurfacesFromRaw.js

@@ -29,7 +29,7 @@ export async function createAndCacheSurfacesFromRaw(segmentationId, rawSurfacesD
         const geometryId = closedSurface.id;
         geometryIds.set(segmentIndex, geometryId);
         return geometryLoader.createAndCacheGeometry(geometryId, {
-            type: Enums.GeometryType.SURFACE,
+            type: Enums.GeometryType.Surface,
             geometryData: closedSurface,
         });
     });

package/dist/esm/stateManagement/segmentation/polySeg/Surface/surfaceComputationStrategies.js

@@ -12,13 +12,13 @@ export async function computeSurfaceData(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
     const representationData = segmentation.representationData;
     try {
-        if (representationData.CONTOUR) {
+        if (representationData.Contour) {
             rawSurfacesData = await computeSurfaceFromContourSegmentation(segmentationId, {
                 segmentIndices,
                 ...options,
             });
         }
-        else if (representationData.LABELMAP) {
+        else if (representationData.Labelmap) {
             rawSurfacesData = await computeSurfaceFromLabelmapSegmentation(segmentation.segmentationId, {
                 segmentIndices,
                 ...options,
@@ -37,12 +37,12 @@ export async function computeSurfaceData(segmentationId, options = {}) {
 }
 async function computeSurfaceFromLabelmapSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    if (!segmentation?.representationData?.LABELMAP) {
+    if (!segmentation?.representationData?.Labelmap) {
         console.warn('Only support surface update from labelmaps');
         return;
     }
-    const isVolume = isVolumeSegmentation(segmentation.representationData.LABELMAP);
-    const labelmapRepresentationData = segmentation.representationData.LABELMAP;
+    const isVolume = isVolumeSegmentation(segmentation.representationData.Labelmap);
+    const labelmapRepresentationData = segmentation.representationData.Labelmap;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map((index) => {
         const surface = convertLabelmapToSurface(labelmapRepresentationData, index, isVolume);
@@ -65,7 +65,7 @@ async function computeSurfaceFromLabelmapSegmentation(segmentationId, options =
 }
 async function computeSurfaceFromContourSegmentation(segmentationId, options = {}) {
     const segmentation = getSegmentation(segmentationId);
-    const contourRepresentationData = segmentation.representationData.CONTOUR;
+    const contourRepresentationData = segmentation.representationData.Contour;
     const segmentIndices = options.segmentIndices || getUniqueSegmentIndices(segmentationId);
     const promises = segmentIndices.map(async (index) => {
         const surface = await convertContourToSurface(contourRepresentationData, index);

package/dist/esm/stateManagement/segmentation/polySeg/Surface/updateSurfaceData.js

@@ -13,7 +13,7 @@ export async function updateSurfaceData(segmentationId) {
     const segmentation = getSegmentation(segmentationId);
     const indices = getUniqueSegmentIndices(segmentationId);
     if (!indices.length) {
-        const geometryIds = segmentation.representationData.SURFACE.geometryIds;
+        const geometryIds = segmentation.representationData.Surface.geometryIds;
         geometryIds.forEach((geometryId) => {
             const geometry = cache.getGeometry(geometryId);
             const surface = geometry.data;
@@ -35,7 +35,7 @@ export async function updateSurfaceData(segmentationId) {
                         SegmentationRepresentations.Surface) {
                         return;
                     }
-                    segmentation.representationData.SURFACE.geometryIds.set(segmentIndex, geometryId);
+                    segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
                     return createAndCacheSurfacesFromRaw(segmentationId, [{ segmentIndex, data }], {
                         segmentationRepresentationUID: segmentationRepresentation.segmentationRepresentationUID,
                     });

package/dist/esm/stateManagement/segmentation/segmentationState.d.ts

@@ -12,7 +12,6 @@ import { setSegmentationRepresentationConfig } from './setSegmentationRepresenta
 import { getPerSegmentConfig } from './getPerSegmentConfig';
 import { setPerSegmentConfig } from './setPerSegmentConfig';
 import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
 import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
@@ -26,4 +25,5 @@ import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepr
 import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };
+import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };

package/dist/esm/stateManagement/segmentation/segmentationState.js

@@ -12,7 +12,6 @@ import { setSegmentationRepresentationConfig } from './setSegmentationRepresenta
 import { getPerSegmentConfig } from './getPerSegmentConfig';
 import { setPerSegmentConfig } from './setPerSegmentConfig';
 import { getSegmentationRepresentations } from './getSegmentationRepresentations';
-import { addSegmentationRepresentation } from './addSegmentationRepresentation';
 import { getSegmentationRepresentationViewportStates } from './getSegmentationRepresentationViewportStates';
 import { addColorLUT } from './addColorLUT';
 import { getColorLUT } from './getColorLUT';
@@ -26,4 +25,5 @@ import { getActiveSegmentationRepresentation } from './getActiveSegmentationRepr
 import { setActiveSegmentationRepresentation } from './setActiveSegmentationRepresentation';
 import { getCurrentLabelmapImageIdForViewport } from './getCurrentLabelmapImageIdForViewport';
 import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegmentationImageReferences';
-export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, addSegmentationRepresentation, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, };
+import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
+export { getSegmentation, getSegmentations, addSegmentation, removeSegmentation, getAllSegmentationRepresentations, getSegmentationRepresentation, removeRepresentation, getGlobalConfig, setGlobalConfig, getSegmentationRepresentationConfig, setSegmentationRepresentationConfig, getPerSegmentConfig, setPerSegmentConfig, getSegmentationRepresentations, getSegmentationRepresentationViewportStates, addColorLUT, getColorLUT, getNextColorLUTIndex, removeColorLUT, getSegmentationRepresentationsForSegmentation, getSegmentationRepresentationVisibility, setSegmentationRepresentationVisibility, getViewportIdsWithSegmentation, getActiveSegmentationRepresentation, setActiveSegmentationRepresentation, getCurrentLabelmapImageIdForViewport, updateLabelmapSegmentationImageReferences, getStackSegmentationImageIdsForViewport, };

package/dist/esm/stateManagement/segmentation/setGlobalConfig.d.ts

@@ -1,2 +1,2 @@
-import type { SegmentationRepresentationConfig } from '../../types';
-export declare function setGlobalConfig(config: SegmentationRepresentationConfig, suppressEvents?: boolean): void;
+import type { GlobalConfig } from '../../types';
+export declare function setGlobalConfig(config: GlobalConfig, suppressEvents?: boolean): void;

package/dist/esm/stateManagement/segmentation/setPerSegmentConfig.d.ts

@@ -1,2 +1,2 @@
-import type { SegmentRepresentationConfig } from '../../types/SegmentationStateTypes';
-export declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: SegmentRepresentationConfig, suppressEvents?: boolean): void;
+import type { RepresentationConfig } from '../../types';
+export declare function setPerSegmentConfig(segmentationRepresentationUID: string, config: RepresentationConfig, suppressEvents?: boolean): void;

package/dist/esm/store/ToolGroupManager/ToolGroup.d.ts

@@ -2,7 +2,7 @@ import { MouseBindings, ToolModes } from '../../enums';
 import type { Types } from '@cornerstonejs/core';
 import type { IToolBinding, IToolGroup, SetToolBindingsType, ToolOptionsType, ToolConfiguration } from '../../types';
 import { MouseCursor } from '../../cursors';
-export default class ToolGroup implements IToolGroup {
+export default class ToolGroup {
     id: string;
     viewportsInfo: any[];
     toolOptions: {};

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -562,7 +562,7 @@ class AdvancedMagnifyViewportManager {
             const { viewportId: sourceViewportId } = evt.detail;
             this._reset(sourceViewportId);
         };
-        element.addEventListener(csEvents.STACK_VIEWPORT_NEW_STACK, newStackHandler);
+        element.addEventListener(csEvents.VIEWPORT_NEW_IMAGE_SET, newStackHandler);
         const newVolumeHandler = (evt) => {
             const { viewportId: sourceViewportId } = evt.detail;
             this._reset(sourceViewportId);
@@ -575,7 +575,7 @@ class AdvancedMagnifyViewportManager {
     _removeSourceElementEventListener(element) {
         element.removeEventListener(csEvents.STACK_NEW_IMAGE, this._newStackImageCallback);
         element.removeEventListener(csEvents.VOLUME_NEW_IMAGE, this._newVolumeImageCallback);
-        element.removeEventListener(csEvents.STACK_VIEWPORT_NEW_STACK, element.newStackHandler);
+        element.removeEventListener(csEvents.VIEWPORT_NEW_IMAGE_SET, element.newStackHandler);
         element.removeEventListener(csEvents.VOLUME_VIEWPORT_NEW_VOLUME, element.newVolumeHandler);
         delete element.newStackHandler;
         delete element.newVolumeHandler;

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/BrushTool.d.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
 import { BaseTool } from '../base';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
 export type PreviewData = {
     preview: unknown;
     timer?: number;
@@ -24,11 +25,22 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
     } | {
         imageId: string;
         segmentsLocked: number[] | [];
         volumeId?: undefined;
         referencedVolumeId?: undefined;
+        override?: undefined;
+    } | {
+        imageId: string;
+        segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
     };
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
@@ -48,8 +60,13 @@ declare class BrushTool extends BaseTool {
         viewUp: any;
         strategySpecificConfiguration: any;
         preview: unknown;
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
         segmentsLocked: number[];
         imageId?: string;
+        imageIds?: string[];
         volumeId?: string;
         referencedVolumeId?: string;
     } | {
@@ -67,6 +84,23 @@ declare class BrushTool extends BaseTool {
         referencedVolumeId: any;
         segmentsLocked: number[] | [];
         imageId?: undefined;
+        override?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        segmentationRepresentationUID: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageId: string;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+        override?: undefined;
     } | {
         points: any;
         segmentIndex: number;
@@ -80,6 +114,10 @@ declare class BrushTool extends BaseTool {
         preview: unknown;
         imageId: string;
         segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
         volumeId?: undefined;
         referencedVolumeId?: undefined;
     };